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,3959 @@
|
|
|
1
|
+
//! What the Wasm Driver answers each preview2 import. Without a network Grant
|
|
2
|
+
//! the guest makes no socket, as wasmtime-wasi's host with sockets disallowed
|
|
3
|
+
//! answers;
|
|
4
|
+
//! with one, each connect passes the Invocation's ruleset and dials through
|
|
5
|
+
//! its Protocol Family. The clock subscriptions, the streams, and `poll` wait
|
|
6
|
+
//! on the runtime's wait primitive.
|
|
7
|
+
|
|
8
|
+
use std::collections::BTreeMap;
|
|
9
|
+
use std::net::{Shutdown, SocketAddr};
|
|
10
|
+
use std::sync::atomic::Ordering;
|
|
11
|
+
use std::sync::{Arc, Mutex};
|
|
12
|
+
use std::time::{Duration, Instant};
|
|
13
|
+
|
|
14
|
+
use kobako_runtime::cred::Cred;
|
|
15
|
+
use kobako_runtime::net::{
|
|
16
|
+
resolve, sock_alloc_file, sys_bind, sys_connect, AddressFamily, Namespace, ProtoOps, SockOpt,
|
|
17
|
+
TcpSock, UdpSock, MAX_DATAGRAM, MAX_TCP_KEEPCNT, MAX_TCP_KEEPIDLE, MAX_TCP_KEEPINTVL,
|
|
18
|
+
};
|
|
19
|
+
use kobako_runtime::sched::{self, FatalSignal};
|
|
20
|
+
use kobako_runtime::vfs::PollMask;
|
|
21
|
+
use kobako_runtime::wait::{do_poll, PollTable};
|
|
22
|
+
use kobako_runtime::Errno;
|
|
23
|
+
|
|
24
|
+
use super::bindings::wasi_clocks_monotonic_clock_0_2_12 as monotonic_clock;
|
|
25
|
+
use super::bindings::wasi_io_error_0_2_12::Error;
|
|
26
|
+
use super::bindings::wasi_io_poll_0_2_12::Pollable;
|
|
27
|
+
use super::bindings::wasi_io_streams_0_2_12::{self as streams, InputStream, OutputStream};
|
|
28
|
+
use super::bindings::wasi_sockets_ip_name_lookup_0_2_12::ResolveAddressStream;
|
|
29
|
+
use super::bindings::wasi_sockets_network_0_2_12::{
|
|
30
|
+
ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
|
|
31
|
+
};
|
|
32
|
+
use super::bindings::wasi_sockets_tcp_0_2_12::{ShutdownType, TcpSocket};
|
|
33
|
+
use super::bindings::wasi_sockets_udp_0_2_12::{
|
|
34
|
+
IncomingDatagram, IncomingDatagramStream, OutgoingDatagram, OutgoingDatagramStream, UdpSocket,
|
|
35
|
+
};
|
|
36
|
+
use super::bindings::{ClocksHost, IoHost, SocketsHost};
|
|
37
|
+
use super::error::{SocketError, StreamError};
|
|
38
|
+
use super::io::{self, EndingStream, SharedFile, SocketFile, Stream};
|
|
39
|
+
use super::sockets::{self, TcpState, UdpState};
|
|
40
|
+
use super::sockets::{
|
|
41
|
+
from_socket_addr, is_valid_unicast_address, to_asked_size, to_buffer_size, to_error_code,
|
|
42
|
+
to_hop_limit, to_ip_address, to_keepalive_secs, to_lookup_error_code, to_remote_addr,
|
|
43
|
+
to_socket_addr,
|
|
44
|
+
};
|
|
45
|
+
use super::table;
|
|
46
|
+
use super::to_nanos;
|
|
47
|
+
use super::MAX_READ_SIZE_ALLOC;
|
|
48
|
+
use crate::invocation::Invocation;
|
|
49
|
+
use crate::trap::{Interrupted, TimeoutTrap};
|
|
50
|
+
|
|
51
|
+
/// The most one `blocking-write-and-flush` takes, past which `io.wit` says the
|
|
52
|
+
/// call traps.
|
|
53
|
+
const MAX_BLOCKING_WRITE: usize = 4096;
|
|
54
|
+
|
|
55
|
+
/// The most datagrams one `receive` answers and one `check-send` permits, as
|
|
56
|
+
/// wasmtime-wasi's.
|
|
57
|
+
const MAX_DATAGRAMS: usize = 16;
|
|
58
|
+
|
|
59
|
+
/// Where a socket stands for a bind, as each protocol reads its own state.
|
|
60
|
+
enum BindStanding {
|
|
61
|
+
Unbound,
|
|
62
|
+
/// A bind or a connect is under way.
|
|
63
|
+
Busy,
|
|
64
|
+
/// Bound, connected, or closed.
|
|
65
|
+
Settled,
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
impl Invocation {
|
|
69
|
+
/// A pollable on the guest's own clocks, `nanos` of host time from now;
|
|
70
|
+
/// the wait holding it decides when it is due.
|
|
71
|
+
fn subscribe_clock(&mut self, nanos: u64) -> wasmtime::Result<Pollable> {
|
|
72
|
+
self.table_mut().push(io::Pollable::Clock {
|
|
73
|
+
at: Instant::now() + Duration::from_nanos(nanos),
|
|
74
|
+
})
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
pub(super) fn table_mut(&mut self) -> &mut table::Table {
|
|
78
|
+
self.wasi_mut().table_mut()
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
/// What `opt` reads of the TCP socket `this`, in a state that takes an
|
|
82
|
+
/// option.
|
|
83
|
+
fn tcp_option(&mut self, this: TcpSocket, opt: SockOpt) -> Result<u32, SocketError> {
|
|
84
|
+
let socket = self.tcp_mut(this)?;
|
|
85
|
+
socket.state.ensure_takes_options()?;
|
|
86
|
+
Ok(socket.socket.sock.getsockopt(opt)?)
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
/// Set `opt` of the TCP socket `this` to `value`, in a state that takes
|
|
90
|
+
/// an option.
|
|
91
|
+
fn set_tcp_option(
|
|
92
|
+
&mut self,
|
|
93
|
+
this: TcpSocket,
|
|
94
|
+
opt: SockOpt,
|
|
95
|
+
value: u32,
|
|
96
|
+
) -> Result<(), SocketError> {
|
|
97
|
+
let socket = self.tcp_mut(this)?;
|
|
98
|
+
socket.state.ensure_takes_options()?;
|
|
99
|
+
Ok(socket.socket.sock.setsockopt(opt, value)?)
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/// Set the buffer size `opt` of the TCP socket `this` to `value`; a
|
|
103
|
+
/// socket that takes no option answers before zero does, as wasmtime
|
|
104
|
+
/// reads the socket before the size.
|
|
105
|
+
fn set_tcp_buffer_size(
|
|
106
|
+
&mut self,
|
|
107
|
+
this: TcpSocket,
|
|
108
|
+
opt: SockOpt,
|
|
109
|
+
value: u64,
|
|
110
|
+
) -> Result<(), SocketError> {
|
|
111
|
+
let socket = self.tcp_mut(this)?;
|
|
112
|
+
socket.state.ensure_takes_options()?;
|
|
113
|
+
let bytes = to_buffer_size(value).ok_or(ErrorCode::InvalidArgument)?;
|
|
114
|
+
Ok(socket.socket.sock.setsockopt(opt, bytes)?)
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/// What `opt` reads of the UDP socket `this`, which takes an option in
|
|
118
|
+
/// any state, as wasmtime's does.
|
|
119
|
+
fn udp_option(&mut self, this: UdpSocket, opt: SockOpt) -> Result<u32, SocketError> {
|
|
120
|
+
Ok(self.udp_mut(this)?.socket.sock.getsockopt(opt)?)
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
/// Set `opt` of the UDP socket `this` to `value`.
|
|
124
|
+
fn set_udp_option(
|
|
125
|
+
&mut self,
|
|
126
|
+
this: UdpSocket,
|
|
127
|
+
opt: SockOpt,
|
|
128
|
+
value: u32,
|
|
129
|
+
) -> Result<(), SocketError> {
|
|
130
|
+
Ok(self.udp_mut(this)?.socket.sock.setsockopt(opt, value)?)
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
/// The indices of `pollables` ready, once one is, as WASI's `poll` finds
|
|
134
|
+
/// them: each clock is due as the profile has it beside any host-side
|
|
135
|
+
/// producer among them. Both encodings wait here, so preview1's
|
|
136
|
+
/// `poll_oneoff` answers by the same rule.
|
|
137
|
+
pub(crate) fn poll_ready(&self, pollables: Vec<io::Pollable>) -> wasmtime::Result<Vec<u32>> {
|
|
138
|
+
let has_producer = pollables.iter().any(io::Pollable::is_producer);
|
|
139
|
+
let profile = self.profile();
|
|
140
|
+
let pollables = pollables
|
|
141
|
+
.into_iter()
|
|
142
|
+
.map(|pollable| pollable.for_wait(profile, has_producer))
|
|
143
|
+
.collect::<Vec<_>>();
|
|
144
|
+
let due = || pollables.iter().filter_map(io::Pollable::due).min();
|
|
145
|
+
self.wait_for(due, |mut table| {
|
|
146
|
+
let ready = (0..pollables.len() as u32)
|
|
147
|
+
.filter(|i| pollables[*i as usize].is_ready(table.as_deref_mut()))
|
|
148
|
+
.collect::<Vec<_>>();
|
|
149
|
+
(!ready.is_empty()).then_some(ready)
|
|
150
|
+
})
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
/// Wait until `ready` answers, or end with `TimeoutTrap` at the deadline
|
|
154
|
+
/// and with `Interrupted` as the frontend interrupts; the wait sleeps
|
|
155
|
+
/// until the soonest pollable is due, or a queue `ready` registered on
|
|
156
|
+
/// wakes.
|
|
157
|
+
fn wait_for<T>(
|
|
158
|
+
&self,
|
|
159
|
+
due: impl Fn() -> Option<Instant>,
|
|
160
|
+
mut ready: impl FnMut(Option<&mut PollTable>) -> Option<T>,
|
|
161
|
+
) -> wasmtime::Result<T> {
|
|
162
|
+
if let Some(answer) = ready(None) {
|
|
163
|
+
return Ok(answer);
|
|
164
|
+
}
|
|
165
|
+
loop {
|
|
166
|
+
match do_poll(&due, &mut ready) {
|
|
167
|
+
Ok(Some(answer)) => return Ok(answer),
|
|
168
|
+
// A due passed, which a pollable reads as ready; one that
|
|
169
|
+
// moved later leaves nothing ready, and the wait goes on.
|
|
170
|
+
Ok(None) => {
|
|
171
|
+
if let Some(answer) = ready(None) {
|
|
172
|
+
return Ok(answer);
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
Err(_) => {
|
|
176
|
+
return Err(match sched::pending_fatal_signal() {
|
|
177
|
+
Some(FatalSignal::Deadline) => wasmtime::Error::new(TimeoutTrap),
|
|
178
|
+
_ => wasmtime::Error::new(Interrupted),
|
|
179
|
+
})
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
/// The Invocation's network, which every socket, lookup, and request is
|
|
186
|
+
/// made in once its entry found one.
|
|
187
|
+
pub(super) fn network(&self) -> &Namespace {
|
|
188
|
+
self.wasi()
|
|
189
|
+
.network()
|
|
190
|
+
.expect("a socket, a lookup, or a request is only made with a network")
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
/// A socket `create` makes in the Invocation's network, with its file,
|
|
194
|
+
/// handed out as the handle `resource` takes, as `__sys_socket` makes one.
|
|
195
|
+
/// With no network it is `access-denied`, as wasmtime-wasi's host with
|
|
196
|
+
/// sockets disallowed answers; past the open file limit
|
|
197
|
+
/// `new-socket-limit`, once the socket was made, as wasmtime pushes the
|
|
198
|
+
/// socket it made.
|
|
199
|
+
fn create_socket<S: ProtoOps + 'static, H: table::Handle>(
|
|
200
|
+
&mut self,
|
|
201
|
+
family: IpAddressFamily,
|
|
202
|
+
create: impl FnOnce(&Namespace, &Arc<Cred>, AddressFamily) -> Result<Arc<S>, Errno>,
|
|
203
|
+
resource: impl FnOnce(SocketFile<S>) -> H::Host,
|
|
204
|
+
) -> Result<H, SocketError> {
|
|
205
|
+
if self.wasi().network().is_none() {
|
|
206
|
+
return Err(ErrorCode::AccessDenied.into());
|
|
207
|
+
}
|
|
208
|
+
let cred = self.wasi().cred().clone();
|
|
209
|
+
let address_family = match family {
|
|
210
|
+
IpAddressFamily::Ipv4 => AddressFamily::Inet,
|
|
211
|
+
IpAddressFamily::Ipv6 => AddressFamily::Inet6,
|
|
212
|
+
};
|
|
213
|
+
let sock = create(self.network(), &cred, address_family)?;
|
|
214
|
+
let Some(room) = self.wasi().table().reserve_producer::<H>()? else {
|
|
215
|
+
return Err(ErrorCode::NewSocketLimit.into());
|
|
216
|
+
};
|
|
217
|
+
let socket = SocketFile::new(sock.clone(), family, sock_alloc_file(sock, &cred));
|
|
218
|
+
Ok(self.table_mut().install(room, resource(socket)))
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
/// A pollable ready once `file`'s poll finds `mask`, a child `parent` must
|
|
222
|
+
/// outlive, as every pollable on a resource is.
|
|
223
|
+
pub(super) fn subscribe_file(
|
|
224
|
+
&mut self,
|
|
225
|
+
file: SharedFile,
|
|
226
|
+
mask: PollMask,
|
|
227
|
+
parent: impl table::Handle,
|
|
228
|
+
) -> wasmtime::Result<Pollable> {
|
|
229
|
+
self.table_mut()
|
|
230
|
+
.push_child(io::Pollable::File(file, mask), parent)
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
/// Start a bind of `sock`, standing at `standing`, to `local_address`, as
|
|
234
|
+
/// both sockets' `start-bind` do in wasmtime's order, the network handle
|
|
235
|
+
/// checked as it was lifted: a bind or connect under way, then any other
|
|
236
|
+
/// state, then the address as WASI takes it for a socket of `family` and
|
|
237
|
+
/// the protocol finds `is_valid`, through the socket hooks to the socket's
|
|
238
|
+
/// own bind.
|
|
239
|
+
fn start_bind(
|
|
240
|
+
&mut self,
|
|
241
|
+
sock: &dyn ProtoOps,
|
|
242
|
+
family: IpAddressFamily,
|
|
243
|
+
local_address: &IpSocketAddress,
|
|
244
|
+
standing: BindStanding,
|
|
245
|
+
is_valid: fn(SocketAddr) -> bool,
|
|
246
|
+
) -> Result<(), SocketError> {
|
|
247
|
+
match standing {
|
|
248
|
+
BindStanding::Unbound => {}
|
|
249
|
+
BindStanding::Busy => return Err(ErrorCode::ConcurrencyConflict.into()),
|
|
250
|
+
BindStanding::Settled => return Err(ErrorCode::InvalidState.into()),
|
|
251
|
+
}
|
|
252
|
+
let addr = to_socket_addr(local_address, family)
|
|
253
|
+
.filter(|addr| is_valid(*addr))
|
|
254
|
+
.ok_or(ErrorCode::InvalidArgument)?;
|
|
255
|
+
let cred = self.wasi().cred().clone();
|
|
256
|
+
Ok(sys_bind(self.network(), &cred, sock, addr)?)
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
fn tcp_mut(&mut self, handle: TcpSocket) -> wasmtime::Result<&mut sockets::TcpSocket> {
|
|
260
|
+
self.table_mut().get_mut(handle)
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
fn udp_mut(&mut self, handle: UdpSocket) -> wasmtime::Result<&mut sockets::UdpSocket> {
|
|
264
|
+
self.table_mut().get_mut(handle)
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
/// The permit an outgoing datagram stream's last `check-send` gave.
|
|
268
|
+
fn permit_mut(&mut self, stream: OutgoingDatagramStream) -> wasmtime::Result<&mut u64> {
|
|
269
|
+
Ok(&mut self.table_mut().get_mut(stream)?.permit)
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
/// Wait until `stream`'s poll finds `mask`, or an error or a hang-up.
|
|
273
|
+
fn wait_on(&self, stream: &Stream, mask: PollMask) -> wasmtime::Result<()> {
|
|
274
|
+
let pollable = io::Pollable::File(stream.shared_file(), mask);
|
|
275
|
+
self.wait_for(|| None, |table| pollable.is_ready(table).then_some(()))
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
/// `call` on a stream still open: one closed answers `closed`, and a call
|
|
279
|
+
/// that fails or answers `closed` closes it, as `io.wit` has every
|
|
280
|
+
/// operation past `last-operation-failed` answer `closed`.
|
|
281
|
+
fn within_open<H, T>(
|
|
282
|
+
&mut self,
|
|
283
|
+
this: H,
|
|
284
|
+
call: impl FnOnce(&mut Self) -> Result<T, StreamError>,
|
|
285
|
+
) -> Result<T, StreamError>
|
|
286
|
+
where
|
|
287
|
+
H: table::Handle,
|
|
288
|
+
H::Host: EndingStream,
|
|
289
|
+
{
|
|
290
|
+
if self.table_mut().get(this)?.closed().load(Ordering::Acquire) {
|
|
291
|
+
return Err(StreamError::Closed);
|
|
292
|
+
}
|
|
293
|
+
let answer = call(self);
|
|
294
|
+
if let Err(StreamError::Closed | StreamError::LastOperationFailed(_)) = answer {
|
|
295
|
+
self.table_mut()
|
|
296
|
+
.get(this)?
|
|
297
|
+
.closed()
|
|
298
|
+
.store(true, Ordering::Release);
|
|
299
|
+
}
|
|
300
|
+
answer
|
|
301
|
+
}
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
impl SocketsHost for Invocation {
|
|
305
|
+
fn network_convert_error_code(&mut self, err: SocketError) -> wasmtime::Result<ErrorCode> {
|
|
306
|
+
err.downcast()
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
fn instance_network_instance_network(&mut self) -> wasmtime::Result<Network> {
|
|
310
|
+
self.table_mut().push(sockets::Network)
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
fn network_network_drop(&mut self, handle: Network) -> wasmtime::Result<()> {
|
|
314
|
+
self.table_mut().delete(handle).map(drop)
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
/// The error code a stream's failure maps to, as a socket call's would,
|
|
318
|
+
/// so the guest reads it without parsing `to-debug-string`.
|
|
319
|
+
fn network_network_error_code(&mut self, err: Error) -> wasmtime::Result<Option<ErrorCode>> {
|
|
320
|
+
let err = &self.table_mut().get(err)?.0;
|
|
321
|
+
Ok(Some(sockets::to_error_code(err)))
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
/// A lookup of `name`, answered through the stream it hands out. Without a
|
|
325
|
+
/// network Grant no resolver answers, as WASI's `permanent-resolver-failure`
|
|
326
|
+
/// says of a host without one.
|
|
327
|
+
fn ip_name_lookup_resolve_addresses(
|
|
328
|
+
&mut self,
|
|
329
|
+
_network: Network,
|
|
330
|
+
name: String,
|
|
331
|
+
) -> Result<ResolveAddressStream, SocketError> {
|
|
332
|
+
let Some(namespace) = self.wasi().network() else {
|
|
333
|
+
return Err(ErrorCode::PermanentResolverFailure.into());
|
|
334
|
+
};
|
|
335
|
+
let Some(room) = self
|
|
336
|
+
.wasi()
|
|
337
|
+
.table()
|
|
338
|
+
.reserve_producer::<ResolveAddressStream>()?
|
|
339
|
+
else {
|
|
340
|
+
return Err(ErrorCode::NewSocketLimit.into());
|
|
341
|
+
};
|
|
342
|
+
let lookup = resolve(namespace, &name).map_err(to_lookup_error_code)?;
|
|
343
|
+
let file = lookup.alloc_file(self.wasi().cred());
|
|
344
|
+
Ok(self.table_mut().install(
|
|
345
|
+
room,
|
|
346
|
+
sockets::ResolveAddressStream {
|
|
347
|
+
lookup,
|
|
348
|
+
file: Arc::new(Mutex::new(file)),
|
|
349
|
+
handed: 0,
|
|
350
|
+
},
|
|
351
|
+
))
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
/// The name's virtual addresses one by one, in the order its lookup
|
|
355
|
+
/// answered, then the end; a lookup still under way answers
|
|
356
|
+
/// `would-block`.
|
|
357
|
+
fn ip_name_lookup_resolve_address_stream_resolve_next_address(
|
|
358
|
+
&mut self,
|
|
359
|
+
this: ResolveAddressStream,
|
|
360
|
+
) -> Result<Option<IpAddress>, SocketError> {
|
|
361
|
+
let stream = self.table_mut().get(this)?;
|
|
362
|
+
let (lookup, handed) = (stream.lookup.clone(), stream.handed);
|
|
363
|
+
let cred = self.wasi().cred();
|
|
364
|
+
let all = match self.network().alloc_virtual_addresses(cred, &lookup) {
|
|
365
|
+
None => return Err(ErrorCode::WouldBlock.into()),
|
|
366
|
+
Some(answer) => answer.map_err(to_lookup_error_code)?,
|
|
367
|
+
};
|
|
368
|
+
let Some(at) = all.get(handed) else {
|
|
369
|
+
return Ok(None);
|
|
370
|
+
};
|
|
371
|
+
self.table_mut().get_mut(this)?.handed = handed + 1;
|
|
372
|
+
Ok(Some(to_ip_address(*at)))
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
fn ip_name_lookup_resolve_address_stream_subscribe(
|
|
376
|
+
&mut self,
|
|
377
|
+
this: ResolveAddressStream,
|
|
378
|
+
) -> wasmtime::Result<Pollable> {
|
|
379
|
+
let file = self.table_mut().get(this)?.file.clone();
|
|
380
|
+
self.subscribe_file(file, PollMask::IN, this)
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
fn ip_name_lookup_resolve_address_stream_drop(
|
|
384
|
+
&mut self,
|
|
385
|
+
handle: ResolveAddressStream,
|
|
386
|
+
) -> wasmtime::Result<()> {
|
|
387
|
+
self.table_mut().delete(handle).map(drop)
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
/// Without a network Grant no socket is made, answered `access-denied` as
|
|
391
|
+
/// wasmtime-wasi's host with sockets disallowed answers; a family the
|
|
392
|
+
/// runtime makes no socket of answers `not-supported`.
|
|
393
|
+
fn tcp_create_socket_create_tcp_socket(
|
|
394
|
+
&mut self,
|
|
395
|
+
address_family: IpAddressFamily,
|
|
396
|
+
) -> Result<TcpSocket, SocketError> {
|
|
397
|
+
self.create_socket(address_family, TcpSock::create, |socket| {
|
|
398
|
+
sockets::TcpSocket {
|
|
399
|
+
socket,
|
|
400
|
+
state: TcpState::Unbound,
|
|
401
|
+
input_closed: Arc::default(),
|
|
402
|
+
}
|
|
403
|
+
})
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
/// A bind the socket hooks pass, as `tcp-socket.start-bind` asks; the
|
|
407
|
+
/// host socket takes its own address as it connects, so a bind settles
|
|
408
|
+
/// at once.
|
|
409
|
+
fn tcp_tcp_socket_start_bind(
|
|
410
|
+
&mut self,
|
|
411
|
+
this: TcpSocket,
|
|
412
|
+
_network: Network,
|
|
413
|
+
local_address: IpSocketAddress,
|
|
414
|
+
) -> Result<(), SocketError> {
|
|
415
|
+
let socket = self.tcp_mut(this)?;
|
|
416
|
+
let standing = match socket.state {
|
|
417
|
+
TcpState::Unbound => BindStanding::Unbound,
|
|
418
|
+
state if state.is_in_progress() => BindStanding::Busy,
|
|
419
|
+
_ => BindStanding::Settled,
|
|
420
|
+
};
|
|
421
|
+
let (sock, family) = (socket.socket.sock.clone(), socket.socket.family);
|
|
422
|
+
self.start_bind(
|
|
423
|
+
sock.as_ref(),
|
|
424
|
+
family,
|
|
425
|
+
&local_address,
|
|
426
|
+
standing,
|
|
427
|
+
is_valid_unicast_address,
|
|
428
|
+
)?;
|
|
429
|
+
self.tcp_mut(this)?.state = TcpState::Binding;
|
|
430
|
+
Ok(())
|
|
431
|
+
}
|
|
432
|
+
|
|
433
|
+
fn tcp_tcp_socket_finish_bind(&mut self, this: TcpSocket) -> Result<(), SocketError> {
|
|
434
|
+
let socket = self.tcp_mut(this)?;
|
|
435
|
+
if socket.state != TcpState::Binding {
|
|
436
|
+
return Err(ErrorCode::NotInProgress.into());
|
|
437
|
+
}
|
|
438
|
+
socket.state = TcpState::Bound;
|
|
439
|
+
Ok(())
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
/// A connect passes the Invocation's namespace on what the guest named,
|
|
443
|
+
/// which dials that exact address without blocking, so this answers at
|
|
444
|
+
/// once.
|
|
445
|
+
fn tcp_tcp_socket_start_connect(
|
|
446
|
+
&mut self,
|
|
447
|
+
this: TcpSocket,
|
|
448
|
+
_network: Network,
|
|
449
|
+
remote_address: IpSocketAddress,
|
|
450
|
+
) -> Result<(), SocketError> {
|
|
451
|
+
let socket = self.tcp_mut(this)?;
|
|
452
|
+
match socket.state {
|
|
453
|
+
TcpState::Unbound | TcpState::Bound => {}
|
|
454
|
+
state if state.is_in_progress() => return Err(ErrorCode::ConcurrencyConflict.into()),
|
|
455
|
+
_ => return Err(ErrorCode::InvalidState.into()),
|
|
456
|
+
}
|
|
457
|
+
let sock = socket.socket.sock.clone();
|
|
458
|
+
let addr = to_remote_addr(&remote_address, socket.socket.family)
|
|
459
|
+
.filter(|addr| is_valid_unicast_address(*addr))
|
|
460
|
+
.ok_or(ErrorCode::InvalidArgument)?;
|
|
461
|
+
let cred = self.wasi().cred();
|
|
462
|
+
// Past the address's own checks the attempt is under way, so its
|
|
463
|
+
// failure waits for `finish-connect`, as wasmtime's connecting future
|
|
464
|
+
// checks permission and dials, and then closes the socket. A full
|
|
465
|
+
// connection count is refused at once, as `would-block` from
|
|
466
|
+
// `finish-connect` would read as a connect still under way.
|
|
467
|
+
self.tcp_mut(this)?.state =
|
|
468
|
+
match sys_connect(self.network(), cred, sock.as_ref(), Some(addr)) {
|
|
469
|
+
Ok(()) => TcpState::Connecting,
|
|
470
|
+
Err(Errno::WouldBlock) => {
|
|
471
|
+
self.tcp_mut(this)?.state = TcpState::Closed(ErrorCode::WouldBlock);
|
|
472
|
+
return Err(ErrorCode::WouldBlock.into());
|
|
473
|
+
}
|
|
474
|
+
Err(err) => TcpState::ConnectFailed(to_error_code(&err)),
|
|
475
|
+
};
|
|
476
|
+
Ok(())
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
/// The streams of a connect that landed, as WASI hands them out once; one
|
|
480
|
+
/// still under way answers `would-block`, and a failed one closes the
|
|
481
|
+
/// socket.
|
|
482
|
+
fn tcp_tcp_socket_finish_connect(
|
|
483
|
+
&mut self,
|
|
484
|
+
this: TcpSocket,
|
|
485
|
+
) -> Result<(InputStream, OutputStream), SocketError> {
|
|
486
|
+
let socket = self.tcp_mut(this)?;
|
|
487
|
+
let finished = match socket.state {
|
|
488
|
+
TcpState::Connecting => socket.socket.sock.take_connect_outcome(),
|
|
489
|
+
TcpState::ConnectFailed(code) => {
|
|
490
|
+
socket.state = TcpState::Closed(code);
|
|
491
|
+
return Err(code.into());
|
|
492
|
+
}
|
|
493
|
+
_ => return Err(ErrorCode::NotInProgress.into()),
|
|
494
|
+
};
|
|
495
|
+
let (socket, input_closed) = (socket.socket.clone(), socket.input_closed.clone());
|
|
496
|
+
match finished {
|
|
497
|
+
Ok(()) => {
|
|
498
|
+
self.tcp_mut(this)?.state = TcpState::Connected;
|
|
499
|
+
let stream = Stream::Socket(socket);
|
|
500
|
+
let input = self.table_mut().push_child(
|
|
501
|
+
io::InputStream::with_closed(stream.clone(), input_closed),
|
|
502
|
+
this,
|
|
503
|
+
)?;
|
|
504
|
+
let output = self
|
|
505
|
+
.table_mut()
|
|
506
|
+
.push_child(io::OutputStream::new(stream), this)?;
|
|
507
|
+
Ok((input, output))
|
|
508
|
+
}
|
|
509
|
+
Err(Errno::WouldBlock) => Err(ErrorCode::WouldBlock.into()),
|
|
510
|
+
Err(err) => {
|
|
511
|
+
let code = to_error_code(&err);
|
|
512
|
+
self.tcp_mut(this)?.state = TcpState::Closed(code);
|
|
513
|
+
Err(code.into())
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
/// Waits on a connect under way whenever it is polled, and is ready
|
|
519
|
+
/// otherwise, as wasmtime's socket pollable waits only on an operation in
|
|
520
|
+
/// progress.
|
|
521
|
+
fn tcp_tcp_socket_subscribe(&mut self, this: TcpSocket) -> wasmtime::Result<Pollable> {
|
|
522
|
+
let socket = self.tcp_mut(this)?.socket.clone();
|
|
523
|
+
self.table_mut()
|
|
524
|
+
.push_child(io::Pollable::TcpSocket(socket), this)
|
|
525
|
+
}
|
|
526
|
+
|
|
527
|
+
fn tcp_tcp_socket_shutdown(
|
|
528
|
+
&mut self,
|
|
529
|
+
this: TcpSocket,
|
|
530
|
+
shutdown_type: ShutdownType,
|
|
531
|
+
) -> Result<(), SocketError> {
|
|
532
|
+
let socket = self.tcp_mut(this)?;
|
|
533
|
+
if socket.state != TcpState::Connected {
|
|
534
|
+
return Err(ErrorCode::InvalidState.into());
|
|
535
|
+
}
|
|
536
|
+
let how = match shutdown_type {
|
|
537
|
+
ShutdownType::Receive => Shutdown::Read,
|
|
538
|
+
ShutdownType::Send => Shutdown::Write,
|
|
539
|
+
ShutdownType::Both => Shutdown::Both,
|
|
540
|
+
};
|
|
541
|
+
// `tcp.wit` closes the input stream and drops what it still queued,
|
|
542
|
+
// where Linux's `SHUT_RD` keeps reading what arrived.
|
|
543
|
+
if how != Shutdown::Write {
|
|
544
|
+
socket.input_closed.store(true, Ordering::Release);
|
|
545
|
+
}
|
|
546
|
+
Ok(socket.socket.sock.shutdown(how)?)
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
/// The guest's own end once connected, at the virtual port the namespace
|
|
550
|
+
/// gave it, and the unspecified end it bound before that. As wasmtime's,
|
|
551
|
+
/// a socket unbound or still connecting answers `invalid-state`, and one
|
|
552
|
+
/// whose connect failed answers its error.
|
|
553
|
+
fn tcp_tcp_socket_local_address(
|
|
554
|
+
&mut self,
|
|
555
|
+
this: TcpSocket,
|
|
556
|
+
) -> Result<IpSocketAddress, SocketError> {
|
|
557
|
+
let socket = self.tcp_mut(this)?;
|
|
558
|
+
match socket.state {
|
|
559
|
+
TcpState::Connected | TcpState::Binding | TcpState::Bound => {
|
|
560
|
+
Ok(from_socket_addr(socket.socket.sock.getname(false)?))
|
|
561
|
+
}
|
|
562
|
+
TcpState::Closed(code) => Err(code.into()),
|
|
563
|
+
TcpState::Unbound | TcpState::Connecting | TcpState::ConnectFailed(_) => {
|
|
564
|
+
Err(ErrorCode::InvalidState.into())
|
|
565
|
+
}
|
|
566
|
+
}
|
|
567
|
+
}
|
|
568
|
+
|
|
569
|
+
/// The peer as the guest named it.
|
|
570
|
+
fn tcp_tcp_socket_remote_address(
|
|
571
|
+
&mut self,
|
|
572
|
+
this: TcpSocket,
|
|
573
|
+
) -> Result<IpSocketAddress, SocketError> {
|
|
574
|
+
let socket = self.tcp_mut(this)?;
|
|
575
|
+
match (socket.state, socket.socket.sock.getname(true)) {
|
|
576
|
+
(TcpState::Connected, Ok(peer)) => Ok(from_socket_addr(peer)),
|
|
577
|
+
(TcpState::Closed(code), _) => Err(code.into()),
|
|
578
|
+
_ => Err(ErrorCode::InvalidState.into()),
|
|
579
|
+
}
|
|
580
|
+
}
|
|
581
|
+
|
|
582
|
+
/// Whether the socket sends keepalive probes, from the socket's own
|
|
583
|
+
/// setting.
|
|
584
|
+
fn tcp_tcp_socket_keep_alive_enabled(&mut self, this: TcpSocket) -> Result<bool, SocketError> {
|
|
585
|
+
Ok(self.tcp_option(this, SockOpt::KeepAlive)? != 0)
|
|
586
|
+
}
|
|
587
|
+
|
|
588
|
+
fn tcp_tcp_socket_set_keep_alive_enabled(
|
|
589
|
+
&mut self,
|
|
590
|
+
this: TcpSocket,
|
|
591
|
+
value: bool,
|
|
592
|
+
) -> Result<(), SocketError> {
|
|
593
|
+
self.set_tcp_option(this, SockOpt::KeepAlive, u32::from(value))
|
|
594
|
+
}
|
|
595
|
+
|
|
596
|
+
fn tcp_tcp_socket_keep_alive_idle_time(&mut self, this: TcpSocket) -> Result<u64, SocketError> {
|
|
597
|
+
let secs = self.tcp_option(this, SockOpt::KeepIdle)?;
|
|
598
|
+
Ok(to_nanos(Duration::from_secs(u64::from(secs))))
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
/// As wasmtime's, zero answers `invalid-argument` and any other time is
|
|
602
|
+
/// clamped to what Linux takes.
|
|
603
|
+
fn tcp_tcp_socket_set_keep_alive_idle_time(
|
|
604
|
+
&mut self,
|
|
605
|
+
this: TcpSocket,
|
|
606
|
+
value: u64,
|
|
607
|
+
) -> Result<(), SocketError> {
|
|
608
|
+
let secs = to_keepalive_secs(value, MAX_TCP_KEEPIDLE).ok_or(ErrorCode::InvalidArgument)?;
|
|
609
|
+
self.set_tcp_option(this, SockOpt::KeepIdle, secs)
|
|
610
|
+
}
|
|
611
|
+
|
|
612
|
+
fn tcp_tcp_socket_keep_alive_interval(&mut self, this: TcpSocket) -> Result<u64, SocketError> {
|
|
613
|
+
let secs = self.tcp_option(this, SockOpt::KeepIntvl)?;
|
|
614
|
+
Ok(to_nanos(Duration::from_secs(u64::from(secs))))
|
|
615
|
+
}
|
|
616
|
+
|
|
617
|
+
fn tcp_tcp_socket_set_keep_alive_interval(
|
|
618
|
+
&mut self,
|
|
619
|
+
this: TcpSocket,
|
|
620
|
+
value: u64,
|
|
621
|
+
) -> Result<(), SocketError> {
|
|
622
|
+
let secs = to_keepalive_secs(value, MAX_TCP_KEEPINTVL).ok_or(ErrorCode::InvalidArgument)?;
|
|
623
|
+
self.set_tcp_option(this, SockOpt::KeepIntvl, secs)
|
|
624
|
+
}
|
|
625
|
+
|
|
626
|
+
fn tcp_tcp_socket_keep_alive_count(&mut self, this: TcpSocket) -> Result<u32, SocketError> {
|
|
627
|
+
self.tcp_option(this, SockOpt::KeepCnt)
|
|
628
|
+
}
|
|
629
|
+
|
|
630
|
+
/// As wasmtime's, zero answers `invalid-argument` and any other count is
|
|
631
|
+
/// clamped to Linux's ceiling.
|
|
632
|
+
fn tcp_tcp_socket_set_keep_alive_count(
|
|
633
|
+
&mut self,
|
|
634
|
+
this: TcpSocket,
|
|
635
|
+
value: u32,
|
|
636
|
+
) -> Result<(), SocketError> {
|
|
637
|
+
if value == 0 {
|
|
638
|
+
return Err(ErrorCode::InvalidArgument.into());
|
|
639
|
+
}
|
|
640
|
+
self.set_tcp_option(this, SockOpt::KeepCnt, value.min(MAX_TCP_KEEPCNT))
|
|
641
|
+
}
|
|
642
|
+
|
|
643
|
+
/// Half what the receive queue holds, as wasmtime answers it on Linux,
|
|
644
|
+
/// so a guest reads back about the size it asked for.
|
|
645
|
+
fn tcp_tcp_socket_receive_buffer_size(&mut self, this: TcpSocket) -> Result<u64, SocketError> {
|
|
646
|
+
Ok(to_asked_size(self.tcp_option(this, SockOpt::RcvBuf)?))
|
|
647
|
+
}
|
|
648
|
+
|
|
649
|
+
fn tcp_tcp_socket_set_receive_buffer_size(
|
|
650
|
+
&mut self,
|
|
651
|
+
this: TcpSocket,
|
|
652
|
+
value: u64,
|
|
653
|
+
) -> Result<(), SocketError> {
|
|
654
|
+
self.set_tcp_buffer_size(this, SockOpt::RcvBuf, value)
|
|
655
|
+
}
|
|
656
|
+
|
|
657
|
+
fn tcp_tcp_socket_send_buffer_size(&mut self, this: TcpSocket) -> Result<u64, SocketError> {
|
|
658
|
+
Ok(to_asked_size(self.tcp_option(this, SockOpt::SndBuf)?))
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
fn tcp_tcp_socket_set_send_buffer_size(
|
|
662
|
+
&mut self,
|
|
663
|
+
this: TcpSocket,
|
|
664
|
+
value: u64,
|
|
665
|
+
) -> Result<(), SocketError> {
|
|
666
|
+
self.set_tcp_buffer_size(this, SockOpt::SndBuf, value)
|
|
667
|
+
}
|
|
668
|
+
|
|
669
|
+
fn tcp_tcp_socket_hop_limit(&mut self, this: TcpSocket) -> Result<u8, SocketError> {
|
|
670
|
+
Ok(to_hop_limit(self.tcp_option(this, SockOpt::Ttl)?))
|
|
671
|
+
}
|
|
672
|
+
|
|
673
|
+
/// Zero answers `invalid-argument`, as the runtime refuses it.
|
|
674
|
+
fn tcp_tcp_socket_set_hop_limit(
|
|
675
|
+
&mut self,
|
|
676
|
+
this: TcpSocket,
|
|
677
|
+
value: u8,
|
|
678
|
+
) -> Result<(), SocketError> {
|
|
679
|
+
self.set_tcp_option(this, SockOpt::Ttl, u32::from(value))
|
|
680
|
+
}
|
|
681
|
+
|
|
682
|
+
fn tcp_tcp_socket_drop(&mut self, handle: TcpSocket) -> wasmtime::Result<()> {
|
|
683
|
+
self.table_mut().delete(handle).map(drop)
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
/// Made as a TCP socket's creation makes one.
|
|
687
|
+
fn udp_create_socket_create_udp_socket(
|
|
688
|
+
&mut self,
|
|
689
|
+
address_family: IpAddressFamily,
|
|
690
|
+
) -> Result<UdpSocket, SocketError> {
|
|
691
|
+
self.create_socket(address_family, UdpSock::create, |socket| {
|
|
692
|
+
sockets::UdpSocket {
|
|
693
|
+
socket,
|
|
694
|
+
state: UdpState::Unbound,
|
|
695
|
+
}
|
|
696
|
+
})
|
|
697
|
+
}
|
|
698
|
+
|
|
699
|
+
/// The guest only sends to a peer it names, so the one bind it makes is
|
|
700
|
+
/// the implicit one, to any address on an ephemeral port; any other is
|
|
701
|
+
/// refused, as Landlock's `BIND_*` rights refuse one.
|
|
702
|
+
fn udp_udp_socket_start_bind(
|
|
703
|
+
&mut self,
|
|
704
|
+
this: UdpSocket,
|
|
705
|
+
_network: Network,
|
|
706
|
+
local_address: IpSocketAddress,
|
|
707
|
+
) -> Result<(), SocketError> {
|
|
708
|
+
let socket = self.udp_mut(this)?;
|
|
709
|
+
let standing = match socket.state {
|
|
710
|
+
UdpState::Unbound => BindStanding::Unbound,
|
|
711
|
+
UdpState::Binding => BindStanding::Busy,
|
|
712
|
+
_ => BindStanding::Settled,
|
|
713
|
+
};
|
|
714
|
+
let (sock, family) = (socket.socket.sock.clone(), socket.socket.family);
|
|
715
|
+
// UDP binds any address WASI takes, as wasmtime asks UDP of its family
|
|
716
|
+
// alone; the socket hooks refuse all but the implicit one.
|
|
717
|
+
self.start_bind(sock.as_ref(), family, &local_address, standing, |_| true)?;
|
|
718
|
+
self.udp_mut(this)?.state = UdpState::Binding;
|
|
719
|
+
Ok(())
|
|
720
|
+
}
|
|
721
|
+
|
|
722
|
+
fn udp_udp_socket_finish_bind(&mut self, this: UdpSocket) -> Result<(), SocketError> {
|
|
723
|
+
let socket = self.udp_mut(this)?;
|
|
724
|
+
if socket.state != UdpState::Binding {
|
|
725
|
+
return Err(ErrorCode::NotInProgress.into());
|
|
726
|
+
}
|
|
727
|
+
socket.state = UdpState::Bound;
|
|
728
|
+
Ok(())
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
/// The guest's own end, once bound, at the virtual port the namespace gave
|
|
732
|
+
/// it as it connected; an unbound socket answers `invalid-state`, as
|
|
733
|
+
/// wasmtime's.
|
|
734
|
+
fn udp_udp_socket_local_address(
|
|
735
|
+
&mut self,
|
|
736
|
+
this: UdpSocket,
|
|
737
|
+
) -> Result<IpSocketAddress, SocketError> {
|
|
738
|
+
let socket = self.udp_mut(this)?;
|
|
739
|
+
if !socket.state.is_bound() {
|
|
740
|
+
return Err(ErrorCode::InvalidState.into());
|
|
741
|
+
}
|
|
742
|
+
Ok(from_socket_addr(socket.socket.sock.getname(false)?))
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
/// The hop limit, from the socket's own setting; a UDP socket takes an
|
|
746
|
+
/// option in any state, as wasmtime's does.
|
|
747
|
+
fn udp_udp_socket_unicast_hop_limit(&mut self, this: UdpSocket) -> Result<u8, SocketError> {
|
|
748
|
+
Ok(to_hop_limit(self.udp_option(this, SockOpt::Ttl)?))
|
|
749
|
+
}
|
|
750
|
+
|
|
751
|
+
fn udp_udp_socket_set_unicast_hop_limit(
|
|
752
|
+
&mut self,
|
|
753
|
+
this: UdpSocket,
|
|
754
|
+
value: u8,
|
|
755
|
+
) -> Result<(), SocketError> {
|
|
756
|
+
self.set_udp_option(this, SockOpt::Ttl, u32::from(value))
|
|
757
|
+
}
|
|
758
|
+
|
|
759
|
+
fn udp_udp_socket_receive_buffer_size(&mut self, this: UdpSocket) -> Result<u64, SocketError> {
|
|
760
|
+
Ok(to_asked_size(self.udp_option(this, SockOpt::RcvBuf)?))
|
|
761
|
+
}
|
|
762
|
+
|
|
763
|
+
fn udp_udp_socket_set_receive_buffer_size(
|
|
764
|
+
&mut self,
|
|
765
|
+
this: UdpSocket,
|
|
766
|
+
value: u64,
|
|
767
|
+
) -> Result<(), SocketError> {
|
|
768
|
+
let bytes = to_buffer_size(value).ok_or(ErrorCode::InvalidArgument)?;
|
|
769
|
+
self.set_udp_option(this, SockOpt::RcvBuf, bytes)
|
|
770
|
+
}
|
|
771
|
+
|
|
772
|
+
fn udp_udp_socket_send_buffer_size(&mut self, this: UdpSocket) -> Result<u64, SocketError> {
|
|
773
|
+
Ok(to_asked_size(self.udp_option(this, SockOpt::SndBuf)?))
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
fn udp_udp_socket_set_send_buffer_size(
|
|
777
|
+
&mut self,
|
|
778
|
+
this: UdpSocket,
|
|
779
|
+
value: u64,
|
|
780
|
+
) -> Result<(), SocketError> {
|
|
781
|
+
let bytes = to_buffer_size(value).ok_or(ErrorCode::InvalidArgument)?;
|
|
782
|
+
self.set_udp_option(this, SockOpt::SndBuf, bytes)
|
|
783
|
+
}
|
|
784
|
+
|
|
785
|
+
/// The streams to the one peer the guest names, which passes the
|
|
786
|
+
/// Invocation's namespace as a connect does. A stream with no peer would
|
|
787
|
+
/// send each datagram anywhere, so it is refused.
|
|
788
|
+
fn udp_udp_socket_stream(
|
|
789
|
+
&mut self,
|
|
790
|
+
this: UdpSocket,
|
|
791
|
+
remote_address: Option<IpSocketAddress>,
|
|
792
|
+
) -> Result<(IncomingDatagramStream, OutgoingDatagramStream), SocketError> {
|
|
793
|
+
let table = self.table_mut();
|
|
794
|
+
if table.has_child::<IncomingDatagramStream>(this)
|
|
795
|
+
|| table.has_child::<OutgoingDatagramStream>(this)
|
|
796
|
+
{
|
|
797
|
+
return Err(wasmtime::Error::msg("UDP streams not dropped yet").into());
|
|
798
|
+
}
|
|
799
|
+
let socket = self.udp_mut(this)?;
|
|
800
|
+
if !socket.state.is_bound() {
|
|
801
|
+
return Err(ErrorCode::InvalidState.into());
|
|
802
|
+
}
|
|
803
|
+
let socket_file = socket.socket.clone();
|
|
804
|
+
let family = socket_file.family;
|
|
805
|
+
let peer = match remote_address
|
|
806
|
+
.as_ref()
|
|
807
|
+
.map(|addr| to_remote_addr(addr, family))
|
|
808
|
+
{
|
|
809
|
+
Some(Some(addr)) => Some(addr),
|
|
810
|
+
Some(None) => return Err(ErrorCode::InvalidArgument.into()),
|
|
811
|
+
None => None,
|
|
812
|
+
};
|
|
813
|
+
let cred = self.wasi().cred();
|
|
814
|
+
sys_connect(self.network(), cred, socket_file.sock.as_ref(), peer)?;
|
|
815
|
+
let incoming = self.table_mut().push_child(
|
|
816
|
+
sockets::IncomingDatagramStream {
|
|
817
|
+
socket: socket_file.clone(),
|
|
818
|
+
peer,
|
|
819
|
+
},
|
|
820
|
+
this,
|
|
821
|
+
)?;
|
|
822
|
+
let outgoing = self.table_mut().push_child(
|
|
823
|
+
sockets::OutgoingDatagramStream {
|
|
824
|
+
socket: socket_file,
|
|
825
|
+
permit: 0,
|
|
826
|
+
},
|
|
827
|
+
this,
|
|
828
|
+
)?;
|
|
829
|
+
Ok((incoming, outgoing))
|
|
830
|
+
}
|
|
831
|
+
|
|
832
|
+
/// Ready at once, since a bind settles as it starts.
|
|
833
|
+
fn udp_udp_socket_subscribe(&mut self, this: UdpSocket) -> wasmtime::Result<Pollable> {
|
|
834
|
+
self.table_mut().push_child(io::Pollable::Ready, this)
|
|
835
|
+
}
|
|
836
|
+
|
|
837
|
+
fn udp_udp_socket_drop(&mut self, handle: UdpSocket) -> wasmtime::Result<()> {
|
|
838
|
+
self.table_mut().delete(handle).map(drop)
|
|
839
|
+
}
|
|
840
|
+
|
|
841
|
+
/// Up to `max_results` datagrams the stream's peer sent, without waiting,
|
|
842
|
+
/// never past `MAX_DATAGRAMS` or about `MAX_READ_SIZE_ALLOC` bytes, each
|
|
843
|
+
/// datagram counting one more for its record; none yet is an empty list.
|
|
844
|
+
/// One an earlier peer sent before the socket moved to this one is
|
|
845
|
+
/// dropped, as wasmtime drops it: a stream is limited to the peer it was
|
|
846
|
+
/// made with, where Linux's socket would still read it.
|
|
847
|
+
fn udp_incoming_datagram_stream_receive(
|
|
848
|
+
&mut self,
|
|
849
|
+
this: IncomingDatagramStream,
|
|
850
|
+
max_results: u64,
|
|
851
|
+
) -> Result<Vec<IncomingDatagram>, SocketError> {
|
|
852
|
+
let stream = self.table_mut().get(this)?;
|
|
853
|
+
let (socket_file, peer) = (stream.socket.clone(), stream.peer);
|
|
854
|
+
let max_results =
|
|
855
|
+
usize::try_from(max_results).map_or(MAX_DATAGRAMS, |max| max.min(MAX_DATAGRAMS));
|
|
856
|
+
let mut received = Vec::new();
|
|
857
|
+
let mut sum = 0;
|
|
858
|
+
let mut buf = vec![0; MAX_DATAGRAM];
|
|
859
|
+
while received.len() < max_results && sum < MAX_READ_SIZE_ALLOC {
|
|
860
|
+
match socket_file.sock.recvmsg(&mut buf) {
|
|
861
|
+
Ok((_, Some(from))) if peer.is_some_and(|peer| peer != from) => {}
|
|
862
|
+
Ok((n, Some(from))) => {
|
|
863
|
+
sum += 1 + n;
|
|
864
|
+
received.push(IncomingDatagram {
|
|
865
|
+
data: buf[..n].to_vec(),
|
|
866
|
+
remote_address: from_socket_addr(from),
|
|
867
|
+
});
|
|
868
|
+
}
|
|
869
|
+
Ok((_, None)) => unreachable!("a UDP socket names each datagram's sender"),
|
|
870
|
+
Err(Errno::WouldBlock) => break,
|
|
871
|
+
Err(err) if received.is_empty() => return Err(err.into()),
|
|
872
|
+
Err(_) => break,
|
|
873
|
+
}
|
|
874
|
+
}
|
|
875
|
+
Ok(received)
|
|
876
|
+
}
|
|
877
|
+
|
|
878
|
+
fn udp_incoming_datagram_stream_subscribe(
|
|
879
|
+
&mut self,
|
|
880
|
+
this: IncomingDatagramStream,
|
|
881
|
+
) -> wasmtime::Result<Pollable> {
|
|
882
|
+
let file = self.table_mut().get(this)?.socket.shared_file();
|
|
883
|
+
self.subscribe_file(file, PollMask::IN, this)
|
|
884
|
+
}
|
|
885
|
+
|
|
886
|
+
fn udp_incoming_datagram_stream_drop(
|
|
887
|
+
&mut self,
|
|
888
|
+
handle: IncomingDatagramStream,
|
|
889
|
+
) -> wasmtime::Result<()> {
|
|
890
|
+
self.table_mut().delete(handle).map(drop)
|
|
891
|
+
}
|
|
892
|
+
|
|
893
|
+
/// `MAX_DATAGRAMS` whenever the stream's pollable is ready, none
|
|
894
|
+
/// otherwise, as wasmtime-wasi's answers both from one readiness; a
|
|
895
|
+
/// pending failure permits, so the `send` it permits answers it, and a
|
|
896
|
+
/// `send` stops where the queue fills.
|
|
897
|
+
fn udp_outgoing_datagram_stream_check_send(
|
|
898
|
+
&mut self,
|
|
899
|
+
this: OutgoingDatagramStream,
|
|
900
|
+
) -> Result<u64, SocketError> {
|
|
901
|
+
let socket_file = self.table_mut().get(this)?.socket.clone();
|
|
902
|
+
let found = socket_file.file().poll(None);
|
|
903
|
+
let permitted = if found.is_ready_for(PollMask::OUT) {
|
|
904
|
+
MAX_DATAGRAMS as u64
|
|
905
|
+
} else {
|
|
906
|
+
0
|
|
907
|
+
};
|
|
908
|
+
*self.permit_mut(this)? = permitted;
|
|
909
|
+
Ok(permitted)
|
|
910
|
+
}
|
|
911
|
+
|
|
912
|
+
/// The datagrams sent in order, until the queue is full; one addressed to
|
|
913
|
+
/// another peer, or past what UDP carries, is refused. More than the last
|
|
914
|
+
/// `check-send` permitted traps, as `udp.wit` says it must, and a send
|
|
915
|
+
/// spends the permit.
|
|
916
|
+
fn udp_outgoing_datagram_stream_send(
|
|
917
|
+
&mut self,
|
|
918
|
+
this: OutgoingDatagramStream,
|
|
919
|
+
datagrams: Vec<OutgoingDatagram>,
|
|
920
|
+
) -> Result<u64, SocketError> {
|
|
921
|
+
if datagrams.is_empty() {
|
|
922
|
+
return Ok(0);
|
|
923
|
+
}
|
|
924
|
+
let permit = std::mem::take(self.permit_mut(this)?);
|
|
925
|
+
if datagrams.len() as u64 > permit {
|
|
926
|
+
return Err(wasmtime::Error::msg(
|
|
927
|
+
"the guest sent more datagrams than check-send permitted",
|
|
928
|
+
)
|
|
929
|
+
.into());
|
|
930
|
+
}
|
|
931
|
+
let socket_file = self.table_mut().get(this)?.socket.clone();
|
|
932
|
+
let mut sent = 0;
|
|
933
|
+
for datagram in datagrams {
|
|
934
|
+
let addressed = datagram
|
|
935
|
+
.remote_address
|
|
936
|
+
.as_ref()
|
|
937
|
+
.map(|addr| to_socket_addr(addr, socket_file.family));
|
|
938
|
+
// Its size is judged before its address, as wasmtime's send asks.
|
|
939
|
+
let refused = if datagram.data.len() > MAX_DATAGRAM {
|
|
940
|
+
Some(ErrorCode::DatagramTooLarge)
|
|
941
|
+
} else if addressed.is_some_and(|addr| addr != socket_file.sock.getname(true).ok()) {
|
|
942
|
+
Some(ErrorCode::InvalidArgument)
|
|
943
|
+
} else {
|
|
944
|
+
match socket_file.file().write(&datagram.data) {
|
|
945
|
+
Ok(_) => None,
|
|
946
|
+
Err(Errno::WouldBlock) => break,
|
|
947
|
+
Err(err) => Some(to_error_code(&err)),
|
|
948
|
+
}
|
|
949
|
+
};
|
|
950
|
+
match refused {
|
|
951
|
+
None => sent += 1,
|
|
952
|
+
Some(code) if sent == 0 => return Err(code.into()),
|
|
953
|
+
Some(_) => break,
|
|
954
|
+
}
|
|
955
|
+
}
|
|
956
|
+
Ok(sent)
|
|
957
|
+
}
|
|
958
|
+
|
|
959
|
+
fn udp_outgoing_datagram_stream_subscribe(
|
|
960
|
+
&mut self,
|
|
961
|
+
this: OutgoingDatagramStream,
|
|
962
|
+
) -> wasmtime::Result<Pollable> {
|
|
963
|
+
let file = self.table_mut().get(this)?.socket.shared_file();
|
|
964
|
+
self.subscribe_file(file, PollMask::OUT, this)
|
|
965
|
+
}
|
|
966
|
+
|
|
967
|
+
fn udp_outgoing_datagram_stream_drop(
|
|
968
|
+
&mut self,
|
|
969
|
+
handle: OutgoingDatagramStream,
|
|
970
|
+
) -> wasmtime::Result<()> {
|
|
971
|
+
self.table_mut().delete(handle).map(drop)
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
|
|
975
|
+
impl IoHost for Invocation {
|
|
976
|
+
/// The end as `closed`, a trap as itself, and any other failure as an
|
|
977
|
+
/// error the guest may read, as wasmtime-wasi-io hands one out.
|
|
978
|
+
fn streams_convert_stream_error(
|
|
979
|
+
&mut self,
|
|
980
|
+
err: StreamError,
|
|
981
|
+
) -> wasmtime::Result<streams::StreamError> {
|
|
982
|
+
match err {
|
|
983
|
+
StreamError::Closed => Ok(streams::StreamError::Closed),
|
|
984
|
+
StreamError::LastOperationFailed(err) => Ok(streams::StreamError::LastOperationFailed(
|
|
985
|
+
self.table_mut().push(io::Error(err))?,
|
|
986
|
+
)),
|
|
987
|
+
StreamError::Trap(trap) => Err(trap),
|
|
988
|
+
}
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
/// What the stream holds now, up to `len`, without waiting: nothing yet
|
|
992
|
+
/// reads as an empty list, and the end as `closed`.
|
|
993
|
+
fn streams_input_stream_read(
|
|
994
|
+
&mut self,
|
|
995
|
+
this: InputStream,
|
|
996
|
+
len: u64,
|
|
997
|
+
) -> Result<Vec<u8>, StreamError> {
|
|
998
|
+
self.within_open(this, |host| {
|
|
999
|
+
let stream = host.table_mut().get(this)?.stream.clone();
|
|
1000
|
+
let mut buf = vec![0; len.min(MAX_READ_SIZE_ALLOC as u64) as usize];
|
|
1001
|
+
match stream.read(&mut buf) {
|
|
1002
|
+
Ok(0) if !buf.is_empty() => Err(StreamError::Closed),
|
|
1003
|
+
Ok(n) => {
|
|
1004
|
+
buf.truncate(n);
|
|
1005
|
+
Ok(buf)
|
|
1006
|
+
}
|
|
1007
|
+
Err(Errno::WouldBlock) => Ok(Vec::new()),
|
|
1008
|
+
Err(err) => Err(err.into()),
|
|
1009
|
+
}
|
|
1010
|
+
})
|
|
1011
|
+
}
|
|
1012
|
+
|
|
1013
|
+
/// A pollable the stream must outlive, as `io.wit` makes it a child.
|
|
1014
|
+
fn streams_input_stream_subscribe(&mut self, this: InputStream) -> wasmtime::Result<Pollable> {
|
|
1015
|
+
let pollable = self.table_mut().get(this)?.pollable();
|
|
1016
|
+
self.table_mut().push_child(pollable, this)
|
|
1017
|
+
}
|
|
1018
|
+
|
|
1019
|
+
fn streams_input_stream_drop(&mut self, handle: InputStream) -> wasmtime::Result<()> {
|
|
1020
|
+
self.table_mut().delete(handle).map(drop)
|
|
1021
|
+
}
|
|
1022
|
+
|
|
1023
|
+
/// Write every byte, at most 4096, waiting for room as it goes, then until
|
|
1024
|
+
/// what was written has left for the host. The stream is asked for room
|
|
1025
|
+
/// at least once, as wasmtime-wasi-io's is, so one closed before a write of
|
|
1026
|
+
/// nothing answers so before any wait. A stream that closed once every
|
|
1027
|
+
/// byte was taken answers success, as wasmtime-wasi-io's does; a failure
|
|
1028
|
+
/// still answers.
|
|
1029
|
+
fn streams_output_stream_blocking_write_and_flush(
|
|
1030
|
+
&mut self,
|
|
1031
|
+
this: OutputStream,
|
|
1032
|
+
contents: Vec<u8>,
|
|
1033
|
+
) -> Result<(), StreamError> {
|
|
1034
|
+
if contents.len() > MAX_BLOCKING_WRITE {
|
|
1035
|
+
return Err(wasmtime::Error::msg(
|
|
1036
|
+
"the guest handed blocking-write-and-flush more than 4096 bytes",
|
|
1037
|
+
)
|
|
1038
|
+
.into());
|
|
1039
|
+
}
|
|
1040
|
+
self.within_open(this, |host| {
|
|
1041
|
+
let stream = host.table_mut().get(this)?.stream.clone();
|
|
1042
|
+
let mut rest = &contents[..];
|
|
1043
|
+
loop {
|
|
1044
|
+
host.wait_on(&stream, PollMask::OUT)?;
|
|
1045
|
+
match stream.write(rest) {
|
|
1046
|
+
Ok(n) => rest = &rest[n..],
|
|
1047
|
+
Err(Errno::WouldBlock) => {}
|
|
1048
|
+
Err(err) => return Err(err.into()),
|
|
1049
|
+
}
|
|
1050
|
+
if rest.is_empty() {
|
|
1051
|
+
break;
|
|
1052
|
+
}
|
|
1053
|
+
}
|
|
1054
|
+
// Registering through the stream's poll puts the wait on its
|
|
1055
|
+
// queue, which a socket's writer wakes after each chunk it sends.
|
|
1056
|
+
// The flush ends once all has left or the stream fails or hangs
|
|
1057
|
+
// up, as its pollable answers during a flush.
|
|
1058
|
+
host.wait_for(
|
|
1059
|
+
|| None,
|
|
1060
|
+
|table| {
|
|
1061
|
+
let ended = stream.poll(table).is_ready_for(PollMask::ERR);
|
|
1062
|
+
(ended || stream.is_drained()).then_some(())
|
|
1063
|
+
},
|
|
1064
|
+
)?;
|
|
1065
|
+
match stream.write(&[]) {
|
|
1066
|
+
Err(Errno::BrokenPipe) => Ok(()),
|
|
1067
|
+
Ok(_) => Ok(()),
|
|
1068
|
+
Err(err) => Err(err.into()),
|
|
1069
|
+
}
|
|
1070
|
+
})
|
|
1071
|
+
}
|
|
1072
|
+
|
|
1073
|
+
/// How many bytes a write takes now, zero while the stream is full or a
|
|
1074
|
+
/// flush is under way; a failed stream answers its failure.
|
|
1075
|
+
fn streams_output_stream_check_write(
|
|
1076
|
+
&mut self,
|
|
1077
|
+
this: OutputStream,
|
|
1078
|
+
) -> Result<u64, StreamError> {
|
|
1079
|
+
self.within_open(this, |host| {
|
|
1080
|
+
let stream = host.table_mut().get(this)?.stream.clone();
|
|
1081
|
+
stream.write(&[])?;
|
|
1082
|
+
let output = host.table_mut().get_mut(this)?;
|
|
1083
|
+
if io::OutputStream::is_flushing(&stream, &output.flushing) {
|
|
1084
|
+
output.permit = 0;
|
|
1085
|
+
return Ok(0);
|
|
1086
|
+
}
|
|
1087
|
+
output.flushing.store(false, Ordering::Release);
|
|
1088
|
+
output.permit = stream.room();
|
|
1089
|
+
Ok(output.permit as u64)
|
|
1090
|
+
})
|
|
1091
|
+
}
|
|
1092
|
+
|
|
1093
|
+
/// Write what `check-write` permitted; more than it permits traps, as
|
|
1094
|
+
/// `io.wit` says a write past the permit must. The permit is for the next
|
|
1095
|
+
/// write only, so a write spends all of it; an empty one leaves it, as
|
|
1096
|
+
/// wasmtime's does.
|
|
1097
|
+
fn streams_output_stream_write(
|
|
1098
|
+
&mut self,
|
|
1099
|
+
this: OutputStream,
|
|
1100
|
+
contents: Vec<u8>,
|
|
1101
|
+
) -> Result<(), StreamError> {
|
|
1102
|
+
self.within_open(this, |host| {
|
|
1103
|
+
let output = host.table_mut().get_mut(this)?;
|
|
1104
|
+
if contents.len() > output.permit {
|
|
1105
|
+
return Err(wasmtime::Error::msg(
|
|
1106
|
+
"the guest wrote past what check-write permitted",
|
|
1107
|
+
)
|
|
1108
|
+
.into());
|
|
1109
|
+
}
|
|
1110
|
+
if !contents.is_empty() {
|
|
1111
|
+
output.permit = 0;
|
|
1112
|
+
}
|
|
1113
|
+
// A socket whose send buffer shrank since check-write has less
|
|
1114
|
+
// room than it permitted; holding the rest would pass the memory
|
|
1115
|
+
// the socket reserved, so the write fails whole, before any byte
|
|
1116
|
+
// leaves, rather than send the peer a stream with a gap. Room only
|
|
1117
|
+
// grows until the write, as the reactor only drains.
|
|
1118
|
+
let stream = output.stream.clone();
|
|
1119
|
+
if stream.room() < contents.len() {
|
|
1120
|
+
return Err(Errno::NoBufferSpace.into());
|
|
1121
|
+
}
|
|
1122
|
+
stream.write(&contents)?;
|
|
1123
|
+
Ok(())
|
|
1124
|
+
})
|
|
1125
|
+
}
|
|
1126
|
+
|
|
1127
|
+
/// Start a flush, which completes once what was written has left for the
|
|
1128
|
+
/// host; `check-write` answers zero until then, as `io.wit` asks.
|
|
1129
|
+
fn streams_output_stream_flush(&mut self, this: OutputStream) -> Result<(), StreamError> {
|
|
1130
|
+
self.within_open(this, |host| {
|
|
1131
|
+
let stream = host.table_mut().get(this)?.stream.clone();
|
|
1132
|
+
stream.write(&[])?;
|
|
1133
|
+
host.table_mut()
|
|
1134
|
+
.get(this)?
|
|
1135
|
+
.flushing
|
|
1136
|
+
.store(true, Ordering::Release);
|
|
1137
|
+
Ok(())
|
|
1138
|
+
})
|
|
1139
|
+
}
|
|
1140
|
+
|
|
1141
|
+
/// A pollable ready once the stream polls writable and no flush is still
|
|
1142
|
+
/// under way, or at once on a closed stream, the stream its parent, as
|
|
1143
|
+
/// `io.wit` makes it a child.
|
|
1144
|
+
fn streams_output_stream_subscribe(
|
|
1145
|
+
&mut self,
|
|
1146
|
+
this: OutputStream,
|
|
1147
|
+
) -> wasmtime::Result<Pollable> {
|
|
1148
|
+
let output = self.table_mut().get(this)?;
|
|
1149
|
+
let pollable = io::Pollable::Output(
|
|
1150
|
+
output.stream.clone(),
|
|
1151
|
+
output.flushing.clone(),
|
|
1152
|
+
output.closed.clone(),
|
|
1153
|
+
);
|
|
1154
|
+
self.table_mut().push_child(pollable, this)
|
|
1155
|
+
}
|
|
1156
|
+
|
|
1157
|
+
fn streams_output_stream_drop(&mut self, handle: OutputStream) -> wasmtime::Result<()> {
|
|
1158
|
+
self.table_mut().delete(handle).map(drop)
|
|
1159
|
+
}
|
|
1160
|
+
|
|
1161
|
+
/// The failure's POSIX name, so no host text reaches the guest.
|
|
1162
|
+
fn error_error_to_debug_string(&mut self, this: Error) -> wasmtime::Result<String> {
|
|
1163
|
+
let err = &self.table_mut().get(this)?.0;
|
|
1164
|
+
Ok(err.posix_name().unwrap_or("EIO").to_string())
|
|
1165
|
+
}
|
|
1166
|
+
|
|
1167
|
+
fn error_error_drop(&mut self, handle: Error) -> wasmtime::Result<()> {
|
|
1168
|
+
self.table_mut().delete(handle).map(drop)
|
|
1169
|
+
}
|
|
1170
|
+
|
|
1171
|
+
fn poll_pollable_block(&mut self, this: Pollable) -> wasmtime::Result<()> {
|
|
1172
|
+
let pollable = self.table_mut().get(this)?.clone();
|
|
1173
|
+
self.poll_ready(vec![pollable]).map(drop)
|
|
1174
|
+
}
|
|
1175
|
+
|
|
1176
|
+
/// The indices of the pollables ready, once one is, in the order the
|
|
1177
|
+
/// guest listed them, as WASI's `poll` answers; an empty list traps, as
|
|
1178
|
+
/// WASI says it does. A handle listed more than once waits once and
|
|
1179
|
+
/// answers at each of its indices, as wasmtime waits once per resource,
|
|
1180
|
+
/// so a long list of one handle costs no more waiters than the handle
|
|
1181
|
+
/// alone.
|
|
1182
|
+
fn poll_poll(&mut self, r#in: Vec<Pollable>) -> wasmtime::Result<Vec<u32>> {
|
|
1183
|
+
if r#in.is_empty() {
|
|
1184
|
+
return Err(wasmtime::Error::msg("poll was handed no pollable"));
|
|
1185
|
+
}
|
|
1186
|
+
let mut indices_of = BTreeMap::<u32, Vec<u32>>::new();
|
|
1187
|
+
for (index, handle) in (0u32..).zip(&r#in) {
|
|
1188
|
+
indices_of.entry(handle.0).or_default().push(index);
|
|
1189
|
+
}
|
|
1190
|
+
let pollables = indices_of
|
|
1191
|
+
.keys()
|
|
1192
|
+
.map(|handle| self.table_mut().get(Pollable(*handle)).cloned())
|
|
1193
|
+
.collect::<wasmtime::Result<Vec<_>>>()?;
|
|
1194
|
+
let ready = self.poll_ready(pollables)?;
|
|
1195
|
+
let lists = indices_of.into_values().collect::<Vec<_>>();
|
|
1196
|
+
let mut answer = ready
|
|
1197
|
+
.into_iter()
|
|
1198
|
+
.flat_map(|at| lists[at as usize].iter().copied())
|
|
1199
|
+
.collect::<Vec<_>>();
|
|
1200
|
+
answer.sort_unstable();
|
|
1201
|
+
Ok(answer)
|
|
1202
|
+
}
|
|
1203
|
+
|
|
1204
|
+
fn poll_pollable_drop(&mut self, handle: Pollable) -> wasmtime::Result<()> {
|
|
1205
|
+
self.table_mut().delete(handle).map(drop)
|
|
1206
|
+
}
|
|
1207
|
+
}
|
|
1208
|
+
|
|
1209
|
+
impl ClocksHost for Invocation {
|
|
1210
|
+
fn monotonic_clock_subscribe_duration(
|
|
1211
|
+
&mut self,
|
|
1212
|
+
when: monotonic_clock::Duration,
|
|
1213
|
+
) -> wasmtime::Result<Pollable> {
|
|
1214
|
+
self.subscribe_clock(when)
|
|
1215
|
+
}
|
|
1216
|
+
}
|
|
1217
|
+
|
|
1218
|
+
#[cfg(test)]
|
|
1219
|
+
mod tests {
|
|
1220
|
+
//! Witness each preview2 import through a core module that links it by its
|
|
1221
|
+
//! WASI name, as a Guest Binary does.
|
|
1222
|
+
use std::time::{Duration, Instant};
|
|
1223
|
+
|
|
1224
|
+
use wasmtime::{Instance, Module, Store};
|
|
1225
|
+
|
|
1226
|
+
use crate::cache::load_engine;
|
|
1227
|
+
use crate::config::Config;
|
|
1228
|
+
use crate::imports;
|
|
1229
|
+
use crate::invocation::Invocation;
|
|
1230
|
+
use crate::trap::NO_TIMEOUT_EPOCH_DELTA;
|
|
1231
|
+
use std::sync::Arc;
|
|
1232
|
+
|
|
1233
|
+
use super::super::bindings::wasi_sockets_network_0_2_12::{
|
|
1234
|
+
Ipv4SocketAddress, Ipv6SocketAddress,
|
|
1235
|
+
};
|
|
1236
|
+
use super::super::bindings::{Host as _, HttpHost};
|
|
1237
|
+
use super::super::error::IntoAnswer;
|
|
1238
|
+
use super::*;
|
|
1239
|
+
use crate::wasi::Wasi;
|
|
1240
|
+
use kobako_runtime::network;
|
|
1241
|
+
use kobako_runtime::profile::Profile;
|
|
1242
|
+
use kobako_runtime::sched::run_task;
|
|
1243
|
+
|
|
1244
|
+
/// Imports one function of each preview2 interface kobako answers, with a
|
|
1245
|
+
/// bump `cabi_realloc` from 4096.
|
|
1246
|
+
const GUEST_WAT: &str = r#"
|
|
1247
|
+
(module
|
|
1248
|
+
(import "wasi:sockets/tcp-create-socket@0.2.12" "create-tcp-socket"
|
|
1249
|
+
(func $create (param i32 i32)))
|
|
1250
|
+
(import "wasi:sockets/instance-network@0.2.12" "instance-network"
|
|
1251
|
+
(func $network (result i32)))
|
|
1252
|
+
(import "wasi:sockets/network@0.2.12" "[resource-drop]network"
|
|
1253
|
+
(func $drop_network (param i32)))
|
|
1254
|
+
(import "wasi:clocks/monotonic-clock@0.2.12" "subscribe-duration"
|
|
1255
|
+
(func $subscribe (param i64) (result i32)))
|
|
1256
|
+
(import "wasi:io/poll@0.2.12" "[method]pollable.block" (func $block (param i32)))
|
|
1257
|
+
(import "wasi:io/poll@0.2.12" "poll" (func $poll (param i32 i32 i32)))
|
|
1258
|
+
(import "wasi:sockets/ip-name-lookup@0.2.12" "resolve-addresses"
|
|
1259
|
+
(func $resolve (param i32 i32 i32 i32)))
|
|
1260
|
+
(import "wasi:sockets/udp@0.2.12" "[method]outgoing-datagram-stream.send"
|
|
1261
|
+
(func $send (param i32 i32 i32 i32)))
|
|
1262
|
+
(import "wasi:http/outgoing-handler@0.2.12" "handle"
|
|
1263
|
+
(func $handle (param i32 i32 i32 i32)))
|
|
1264
|
+
(import "wasi_snapshot_preview1" "sock_accept"
|
|
1265
|
+
(func $sock_accept (param i32 i32 i32) (result i32)))
|
|
1266
|
+
(import "wasi_snapshot_preview1" "sock_recv"
|
|
1267
|
+
(func $sock_recv (param i32 i32 i32 i32 i32 i32) (result i32)))
|
|
1268
|
+
(import "wasi_snapshot_preview1" "sock_send"
|
|
1269
|
+
(func $sock_send (param i32 i32 i32 i32 i32) (result i32)))
|
|
1270
|
+
(import "wasi_snapshot_preview1" "sock_shutdown"
|
|
1271
|
+
(func $sock_shutdown (param i32 i32) (result i32)))
|
|
1272
|
+
(import "wasi_snapshot_preview1" "fd_fdstat_get"
|
|
1273
|
+
(func $fd_fdstat_get (param i32 i32) (result i32)))
|
|
1274
|
+
(memory (export "memory") 1)
|
|
1275
|
+
(global $bump (mut i32) (i32.const 4096))
|
|
1276
|
+
(func (export "cabi_realloc") (param i32 i32 i32 i32) (result i32)
|
|
1277
|
+
(global.get $bump)
|
|
1278
|
+
(global.set $bump (i32.add (global.get $bump) (local.get 3))))
|
|
1279
|
+
(func (export "create_ipv4") (call $create (i32.const 0) (i32.const 16)))
|
|
1280
|
+
(func (export "network") (result i32) (call $network))
|
|
1281
|
+
(func (export "drop_network") (param i32) (call $drop_network (local.get 0)))
|
|
1282
|
+
(func (export "subscribe") (param i64) (result i32) (call $subscribe (local.get 0)))
|
|
1283
|
+
(func (export "block") (param i32) (call $block (local.get 0)))
|
|
1284
|
+
(func (export "poll") (param i32 i32)
|
|
1285
|
+
(i32.store (i32.const 64) (local.get 0))
|
|
1286
|
+
(call $poll (i32.const 64) (local.get 1) (i32.const 32)))
|
|
1287
|
+
(func (export "resolve") (param i32 i32)
|
|
1288
|
+
(call $resolve (local.get 0) (i32.const 128) (local.get 1) (i32.const 32)))
|
|
1289
|
+
(func (export "resolve_into") (param i32 i32)
|
|
1290
|
+
(call $resolve (local.get 0) (i32.const 128) (i32.const 0) (local.get 1)))
|
|
1291
|
+
(func (export "send") (param i32 i32 i32)
|
|
1292
|
+
(call $send (local.get 0) (local.get 1) (local.get 2) (i32.const 32)))
|
|
1293
|
+
(func (export "handle") (param i32 i32 i32)
|
|
1294
|
+
(call $handle (local.get 0) (local.get 1) (local.get 2) (i32.const 32)))
|
|
1295
|
+
(func (export "sock_accept") (param i32) (result i32)
|
|
1296
|
+
(call $sock_accept (local.get 0) (i32.const 0) (i32.const 256)))
|
|
1297
|
+
(func (export "sock_recv") (param i32) (result i32)
|
|
1298
|
+
(call $sock_recv (local.get 0) (i32.const 256) (i32.const 0) (i32.const 0)
|
|
1299
|
+
(i32.const 272) (i32.const 276)))
|
|
1300
|
+
(func (export "sock_send") (param i32) (result i32)
|
|
1301
|
+
(call $sock_send (local.get 0) (i32.const 256) (i32.const 0) (i32.const 0)
|
|
1302
|
+
(i32.const 272)))
|
|
1303
|
+
(func (export "sock_shutdown") (param i32) (result i32)
|
|
1304
|
+
(call $sock_shutdown (local.get 0) (i32.const 3)))
|
|
1305
|
+
(func (export "fdstat") (param i32) (result i32)
|
|
1306
|
+
(call $fd_fdstat_get (local.get 0) (i32.const 256))))
|
|
1307
|
+
"#;
|
|
1308
|
+
|
|
1309
|
+
/// A guest at `profile`, holding at most `open_file_limit` files.
|
|
1310
|
+
fn guest(profile: Profile, open_file_limit: Option<usize>) -> (Store<Invocation>, Instance) {
|
|
1311
|
+
let mut config = Config::for_profile(profile);
|
|
1312
|
+
config.limits.open_file_limit = open_file_limit;
|
|
1313
|
+
guest_of(config)
|
|
1314
|
+
}
|
|
1315
|
+
|
|
1316
|
+
/// The guest module, instantiated over an Invocation `config` builds.
|
|
1317
|
+
fn guest_of(config: Config) -> (Store<Invocation>, Instance) {
|
|
1318
|
+
let wasi = Wasi::for_invocation(&config, &[]).expect("WASI context must build");
|
|
1319
|
+
instantiate(Invocation::new(wasi))
|
|
1320
|
+
}
|
|
1321
|
+
|
|
1322
|
+
/// The guest module, instantiated over `invocation`.
|
|
1323
|
+
fn instantiate(invocation: Invocation) -> (Store<Invocation>, Instance) {
|
|
1324
|
+
let engine = load_engine().expect("shared engine must be constructible");
|
|
1325
|
+
let mut store = Store::new(engine, invocation);
|
|
1326
|
+
store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
|
|
1327
|
+
let module = Module::new(engine, GUEST_WAT).expect("the guest module must compile");
|
|
1328
|
+
let instance = imports::linker()
|
|
1329
|
+
.expect("host imports must link")
|
|
1330
|
+
.instantiate(&mut store, &module)
|
|
1331
|
+
.expect("every preview2 import the module names must link");
|
|
1332
|
+
(store, instance)
|
|
1333
|
+
}
|
|
1334
|
+
|
|
1335
|
+
fn call<P: wasmtime::WasmParams, R: wasmtime::WasmResults>(
|
|
1336
|
+
store: &mut Store<Invocation>,
|
|
1337
|
+
instance: &Instance,
|
|
1338
|
+
name: &str,
|
|
1339
|
+
params: P,
|
|
1340
|
+
) -> wasmtime::Result<R> {
|
|
1341
|
+
instance
|
|
1342
|
+
.get_typed_func::<P, R>(&mut *store, name)
|
|
1343
|
+
.expect("the guest module exports each call")
|
|
1344
|
+
.call(&mut *store, params)
|
|
1345
|
+
}
|
|
1346
|
+
|
|
1347
|
+
fn read(store: &mut Store<Invocation>, instance: &Instance, at: usize, len: usize) -> Vec<u8> {
|
|
1348
|
+
let memory = instance.get_memory(&mut *store, "memory").expect("memory");
|
|
1349
|
+
memory.data(&*store)[at..at + len].to_vec()
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1352
|
+
// @behavior NW-009
|
|
1353
|
+
#[test]
|
|
1354
|
+
fn without_the_network_creating_a_socket_answers_access_denied() {
|
|
1355
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1356
|
+
call::<(), ()>(&mut store, &instance, "create_ipv4", ()).expect("the call answers");
|
|
1357
|
+
let answer = read(&mut store, &instance, 16, 5);
|
|
1358
|
+
assert_eq!(
|
|
1359
|
+
(answer[0], answer[4]),
|
|
1360
|
+
(1, 1),
|
|
1361
|
+
"create-tcp-socket with no network entry must answer err(access-denied)"
|
|
1362
|
+
);
|
|
1363
|
+
}
|
|
1364
|
+
|
|
1365
|
+
// @behavior NW-010
|
|
1366
|
+
#[test]
|
|
1367
|
+
fn the_network_is_one_handle_the_guest_may_drop() {
|
|
1368
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1369
|
+
let network = call::<(), i32>(&mut store, &instance, "network", ()).expect("a handle");
|
|
1370
|
+
let first = call::<i32, ()>(&mut store, &instance, "drop_network", network);
|
|
1371
|
+
let second = call::<i32, ()>(&mut store, &instance, "drop_network", network);
|
|
1372
|
+
assert!(
|
|
1373
|
+
first.is_ok() && second.is_err(),
|
|
1374
|
+
"[resource-drop]network of the handle instance-network answered must succeed once and \
|
|
1375
|
+
then trap"
|
|
1376
|
+
);
|
|
1377
|
+
}
|
|
1378
|
+
|
|
1379
|
+
/// A host that has given every invocation up.
|
|
1380
|
+
struct AbandonsCalls;
|
|
1381
|
+
|
|
1382
|
+
impl kobako_runtime::DispatchHandler for AbandonsCalls {
|
|
1383
|
+
fn dispatch(
|
|
1384
|
+
&self,
|
|
1385
|
+
_call: kobako_transport::envelope::Call<'_>,
|
|
1386
|
+
_yielder: &mut dyn kobako_runtime::yielder::Yielder,
|
|
1387
|
+
) -> Option<kobako_transport::envelope::CallReply> {
|
|
1388
|
+
None
|
|
1389
|
+
}
|
|
1390
|
+
|
|
1391
|
+
fn abandoned(&self) -> bool {
|
|
1392
|
+
true
|
|
1393
|
+
}
|
|
1394
|
+
}
|
|
1395
|
+
|
|
1396
|
+
// @behavior RT-354
|
|
1397
|
+
#[test]
|
|
1398
|
+
fn a_preview2_call_answered_after_the_host_gave_up_traps() {
|
|
1399
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1400
|
+
store.data_mut().bind_on_dispatch(Arc::new(AbandonsCalls));
|
|
1401
|
+
let network = call::<(), i32>(&mut store, &instance, "network", ());
|
|
1402
|
+
let created = call::<(), ()>(&mut store, &instance, "create_ipv4", ());
|
|
1403
|
+
assert_eq!(
|
|
1404
|
+
(
|
|
1405
|
+
network.map_err(|trap| trap.root_cause().to_string()),
|
|
1406
|
+
created.map_err(|trap| trap.root_cause().to_string())
|
|
1407
|
+
),
|
|
1408
|
+
(
|
|
1409
|
+
Err(kobako_runtime::endpoint::ABANDONED.to_string()),
|
|
1410
|
+
Err(kobako_runtime::endpoint::ABANDONED.to_string())
|
|
1411
|
+
),
|
|
1412
|
+
"instance-network and create-tcp-socket answered after the host abandoned the \
|
|
1413
|
+
invocation must each trap as abandoned"
|
|
1414
|
+
);
|
|
1415
|
+
}
|
|
1416
|
+
|
|
1417
|
+
// @behavior RT-353
|
|
1418
|
+
#[test]
|
|
1419
|
+
fn a_list_past_the_guests_memory_traps_before_the_host_reads_it() {
|
|
1420
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1421
|
+
let network = call::<(), i32>(&mut store, &instance, "network", ()).expect("a handle");
|
|
1422
|
+
for len in [-1, 1 << 20] {
|
|
1423
|
+
let polled = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
|
1424
|
+
call::<(i32, i32), ()>(&mut store, &instance, "poll", (0, len))
|
|
1425
|
+
}));
|
|
1426
|
+
let resolved = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
|
1427
|
+
call::<(i32, i32), ()>(&mut store, &instance, "resolve", (network, len))
|
|
1428
|
+
}));
|
|
1429
|
+
assert!(
|
|
1430
|
+
matches!((polled, resolved), (Ok(Err(_)), Ok(Err(_)))),
|
|
1431
|
+
"wasi:io/poll.poll naming {len} pollables, and resolve-addresses naming a {len}-byte \
|
|
1432
|
+
name, each past one page of memory, must trap rather than panic or answer"
|
|
1433
|
+
);
|
|
1434
|
+
}
|
|
1435
|
+
}
|
|
1436
|
+
|
|
1437
|
+
// @behavior NW-163
|
|
1438
|
+
#[test]
|
|
1439
|
+
fn a_handle_the_guest_does_not_hold_traps_as_it_is_lifted() {
|
|
1440
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1441
|
+
let mut request = || {
|
|
1442
|
+
let guest = store.data_mut();
|
|
1443
|
+
let headers = guest.types_fields_new()?;
|
|
1444
|
+
let headers = guest.take_handle(headers)?;
|
|
1445
|
+
guest
|
|
1446
|
+
.types_outgoing_request_new(headers)
|
|
1447
|
+
.map(|r| r.0 as i32)
|
|
1448
|
+
};
|
|
1449
|
+
let (named, unnamed) = (request().unwrap(), request().unwrap());
|
|
1450
|
+
let with_options =
|
|
1451
|
+
call::<(i32, i32, i32), ()>(&mut store, &instance, "handle", (named, 1, 7))
|
|
1452
|
+
.map_err(|trap| trap.root_cause().to_string());
|
|
1453
|
+
let without = call::<(i32, i32, i32), ()>(&mut store, &instance, "handle", (unnamed, 0, 0))
|
|
1454
|
+
.map_err(|trap| trap.root_cause().to_string());
|
|
1455
|
+
assert_eq!(
|
|
1456
|
+
(with_options, without),
|
|
1457
|
+
(
|
|
1458
|
+
Err("the guest named a handle it does not hold".to_string()),
|
|
1459
|
+
Ok(())
|
|
1460
|
+
),
|
|
1461
|
+
"outgoing-handler.handle naming request-options the guest was never handed must trap \
|
|
1462
|
+
as the handle is lifted, as wasmtime's, and a request with no options must be answered"
|
|
1463
|
+
);
|
|
1464
|
+
}
|
|
1465
|
+
|
|
1466
|
+
// @behavior RT-374
|
|
1467
|
+
#[test]
|
|
1468
|
+
fn lists_past_the_calls_hostcall_fuel_trap_before_the_host_answers() {
|
|
1469
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
1470
|
+
let port = peer.local_addr().unwrap().port();
|
|
1471
|
+
let (mut store, instance) = instantiate(network_guest(
|
|
1472
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
1473
|
+
.unwrap()
|
|
1474
|
+
.with_protocol(network::Protocol::Udp),
|
|
1475
|
+
));
|
|
1476
|
+
let outgoing = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
1477
|
+
let guest = store.data_mut();
|
|
1478
|
+
let network = guest.instance_network_instance_network()?;
|
|
1479
|
+
let socket = guest
|
|
1480
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
1481
|
+
.into_answer()?
|
|
1482
|
+
.expect("a network makes a socket");
|
|
1483
|
+
guest
|
|
1484
|
+
.udp_udp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
1485
|
+
.into_answer()?
|
|
1486
|
+
.expect("an ephemeral bind is the implicit one");
|
|
1487
|
+
guest
|
|
1488
|
+
.udp_udp_socket_finish_bind(socket)
|
|
1489
|
+
.into_answer()?
|
|
1490
|
+
.expect("the bind settles");
|
|
1491
|
+
let (_, outgoing) = guest
|
|
1492
|
+
.udp_udp_socket_stream(socket, Some(ipv4((127, 0, 0, 1), port)))
|
|
1493
|
+
.into_answer()?
|
|
1494
|
+
.expect("the udp endpoint names the peer");
|
|
1495
|
+
Ok::<_, wasmtime::Error>(outgoing)
|
|
1496
|
+
})
|
|
1497
|
+
.expect("the stream is made");
|
|
1498
|
+
let memory = instance.get_memory(&mut store, "memory").expect("memory");
|
|
1499
|
+
memory.grow(&mut store, 3).expect("four pages");
|
|
1500
|
+
// Each datagram's data names the same 60000 bytes at 0, so 2400 of
|
|
1501
|
+
// them name 144 MB while the guest holds 256 KiB.
|
|
1502
|
+
const RECORDS_AT: usize = 65536;
|
|
1503
|
+
for i in 0..2400 {
|
|
1504
|
+
let record = RECORDS_AT + i * 44;
|
|
1505
|
+
memory.data_mut(&mut store)[record + 4..record + 8]
|
|
1506
|
+
.copy_from_slice(&60_000u32.to_le_bytes());
|
|
1507
|
+
}
|
|
1508
|
+
// No send was permitted, so a call the lift lets through traps there.
|
|
1509
|
+
let stream = outgoing.0 as i32;
|
|
1510
|
+
let answer = |store: &mut Store<Invocation>, count: i32| {
|
|
1511
|
+
call::<(i32, i32, i32), ()>(
|
|
1512
|
+
store,
|
|
1513
|
+
&instance,
|
|
1514
|
+
"send",
|
|
1515
|
+
(stream, RECORDS_AT as i32, count),
|
|
1516
|
+
)
|
|
1517
|
+
.map_err(|trap| trap.root_cause().to_string())
|
|
1518
|
+
};
|
|
1519
|
+
let past = answer(&mut store, 2400);
|
|
1520
|
+
let within = answer(&mut store, 2);
|
|
1521
|
+
assert!(
|
|
1522
|
+
past.as_ref()
|
|
1523
|
+
.is_err_and(|trap| trap.contains("hostcall fuel"))
|
|
1524
|
+
&& within
|
|
1525
|
+
.as_ref()
|
|
1526
|
+
.is_err_and(|trap| trap.contains("more datagrams than check-send permitted")),
|
|
1527
|
+
"outgoing-datagram-stream.send of 2400 datagrams naming one 60000-byte region must \
|
|
1528
|
+
trap on its hostcall fuel before the host answers, and of two must reach the host; \
|
|
1529
|
+
got {past:?} and {within:?}"
|
|
1530
|
+
);
|
|
1531
|
+
}
|
|
1532
|
+
|
|
1533
|
+
// @behavior RT-373
|
|
1534
|
+
#[test]
|
|
1535
|
+
fn an_answer_into_a_misplaced_return_area_traps() {
|
|
1536
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1537
|
+
let network = call::<(), i32>(&mut store, &instance, "network", ()).expect("a handle");
|
|
1538
|
+
let memory = instance.get_memory(&mut store, "memory").expect("memory");
|
|
1539
|
+
let last = memory.data_size(&store) - 4;
|
|
1540
|
+
memory.data_mut(&mut store)[last..].fill(0xAA);
|
|
1541
|
+
let misaligned =
|
|
1542
|
+
call::<(i32, i32), ()>(&mut store, &instance, "resolve_into", (network, 33));
|
|
1543
|
+
let past_memory = call::<(i32, i32), ()>(
|
|
1544
|
+
&mut store,
|
|
1545
|
+
&instance,
|
|
1546
|
+
"resolve_into",
|
|
1547
|
+
(network, last as i32),
|
|
1548
|
+
);
|
|
1549
|
+
let untouched = memory.data(&store)[last..] == [0xAA; 4];
|
|
1550
|
+
let inside = call::<(i32, i32), ()>(&mut store, &instance, "resolve_into", (network, 32));
|
|
1551
|
+
assert!(
|
|
1552
|
+
misaligned.is_err() && past_memory.is_err() && untouched && inside.is_ok(),
|
|
1553
|
+
"resolve-addresses answering into a return area off its 4-byte alignment, or running \
|
|
1554
|
+
past the guest's memory, must trap before writing any part of the answer, as the \
|
|
1555
|
+
Canonical ABI does, and answer into one wholly inside"
|
|
1556
|
+
);
|
|
1557
|
+
}
|
|
1558
|
+
|
|
1559
|
+
// @behavior RT-338
|
|
1560
|
+
#[test]
|
|
1561
|
+
fn a_clock_wait_on_the_hermetic_profile_ends_at_once() {
|
|
1562
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
1563
|
+
let started = Instant::now();
|
|
1564
|
+
let pollable = call::<i64, i32>(&mut store, &instance, "subscribe", 10_000_000_000)
|
|
1565
|
+
.expect("a pollable");
|
|
1566
|
+
call::<i32, ()>(&mut store, &instance, "block", pollable).expect("the wait answers");
|
|
1567
|
+
assert!(
|
|
1568
|
+
started.elapsed() < Duration::from_secs(1),
|
|
1569
|
+
"pollable.block on ten seconds of subscribe-duration on the hermetic profile must \
|
|
1570
|
+
return at once, not after {:?}",
|
|
1571
|
+
started.elapsed()
|
|
1572
|
+
);
|
|
1573
|
+
}
|
|
1574
|
+
|
|
1575
|
+
// @behavior RT-371
|
|
1576
|
+
#[test]
|
|
1577
|
+
fn a_hermetic_poll_on_two_clocks_finds_both_ready() {
|
|
1578
|
+
let (mut store, _) = guest(Profile::Hermetic, None);
|
|
1579
|
+
let guest = store.data_mut();
|
|
1580
|
+
let clocks = [1_000_000_000, 2_000_000_000]
|
|
1581
|
+
.map(|nanos| guest.monotonic_clock_subscribe_duration(nanos).unwrap());
|
|
1582
|
+
let ready = guest.poll_poll(clocks.to_vec()).unwrap();
|
|
1583
|
+
assert_eq!(
|
|
1584
|
+
ready,
|
|
1585
|
+
[0, 1],
|
|
1586
|
+
"poll on a one- and a two-second subscribe-duration at the hermetic profile must \
|
|
1587
|
+
find both ready at once"
|
|
1588
|
+
);
|
|
1589
|
+
}
|
|
1590
|
+
|
|
1591
|
+
// @behavior RT-387
|
|
1592
|
+
#[test]
|
|
1593
|
+
fn a_pollable_listed_twice_answers_at_each_index() {
|
|
1594
|
+
let (mut store, _) = guest(Profile::Permissive, None);
|
|
1595
|
+
let guest = store.data_mut();
|
|
1596
|
+
let far = guest
|
|
1597
|
+
.monotonic_clock_subscribe_duration(60_000_000_000)
|
|
1598
|
+
.unwrap();
|
|
1599
|
+
let near = guest.monotonic_clock_subscribe_duration(1_000_000).unwrap();
|
|
1600
|
+
let ready = guest.poll_poll(vec![far, near, far, near]).unwrap();
|
|
1601
|
+
assert_eq!(
|
|
1602
|
+
ready,
|
|
1603
|
+
[1, 3],
|
|
1604
|
+
"poll on a list naming a far and a near clock twice each must answer both indices of \
|
|
1605
|
+
the near clock"
|
|
1606
|
+
);
|
|
1607
|
+
}
|
|
1608
|
+
|
|
1609
|
+
// @behavior RT-339
|
|
1610
|
+
#[test]
|
|
1611
|
+
fn a_poll_on_a_clock_waits_until_it_is_due() {
|
|
1612
|
+
let (mut store, instance) = guest(Profile::Permissive, None);
|
|
1613
|
+
let started = Instant::now();
|
|
1614
|
+
let pollable =
|
|
1615
|
+
call::<i64, i32>(&mut store, &instance, "subscribe", 50_000_000).expect("a pollable");
|
|
1616
|
+
run_task(Some(started + Duration::from_secs(10)), || {
|
|
1617
|
+
call::<(i32, i32), ()>(&mut store, &instance, "poll", (pollable, 1))
|
|
1618
|
+
})
|
|
1619
|
+
.expect("the poll answers");
|
|
1620
|
+
let spent = started.elapsed();
|
|
1621
|
+
let answer = read(&mut store, &instance, 32, 8);
|
|
1622
|
+
let (at, len) = (
|
|
1623
|
+
u32::from_le_bytes(answer[..4].try_into().unwrap()) as usize,
|
|
1624
|
+
u32::from_le_bytes(answer[4..].try_into().unwrap()),
|
|
1625
|
+
);
|
|
1626
|
+
let index = u32::from_le_bytes(read(&mut store, &instance, at, 4).try_into().unwrap());
|
|
1627
|
+
assert!(
|
|
1628
|
+
(len, index) == (1, 0)
|
|
1629
|
+
&& spent >= Duration::from_millis(50)
|
|
1630
|
+
&& spent < Duration::from_secs(5),
|
|
1631
|
+
"poll of one pollable on fifty milliseconds of subscribe-duration on the permissive \
|
|
1632
|
+
profile must answer [0] once they pass, got {len} index {index} after {spent:?}"
|
|
1633
|
+
);
|
|
1634
|
+
}
|
|
1635
|
+
|
|
1636
|
+
/// A hermetic invocation whose network reaches `port` on loopback over TCP.
|
|
1637
|
+
fn loopback_guest(port: u16) -> Invocation {
|
|
1638
|
+
network_guest(
|
|
1639
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
1640
|
+
.unwrap()
|
|
1641
|
+
.with_protocol(network::Protocol::Tcp),
|
|
1642
|
+
)
|
|
1643
|
+
}
|
|
1644
|
+
|
|
1645
|
+
/// A hermetic invocation whose network holds `endpoint`, or none.
|
|
1646
|
+
fn network_guest(endpoint: network::Endpoint) -> Invocation {
|
|
1647
|
+
limited_network_guest([endpoint], None)
|
|
1648
|
+
}
|
|
1649
|
+
|
|
1650
|
+
/// A hermetic invocation whose network holds `endpoints`, holding at most
|
|
1651
|
+
/// `open_file_limit` files.
|
|
1652
|
+
fn limited_network_guest(
|
|
1653
|
+
endpoints: impl IntoIterator<Item = network::Endpoint>,
|
|
1654
|
+
open_file_limit: Option<usize>,
|
|
1655
|
+
) -> Invocation {
|
|
1656
|
+
Invocation::hermetic(Some(endpoints.into_iter().collect()), |config| {
|
|
1657
|
+
config.limits.open_file_limit = open_file_limit
|
|
1658
|
+
})
|
|
1659
|
+
}
|
|
1660
|
+
|
|
1661
|
+
// @behavior NW-030
|
|
1662
|
+
#[test]
|
|
1663
|
+
fn without_the_network_a_lookup_answers_permanent_resolver_failure() {
|
|
1664
|
+
let (mut store, _instance) = guest(Profile::Hermetic, None);
|
|
1665
|
+
let guest = store.data_mut();
|
|
1666
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
1667
|
+
assert!(
|
|
1668
|
+
matches!(
|
|
1669
|
+
guest
|
|
1670
|
+
.ip_name_lookup_resolve_addresses(network, "example.com".to_string())
|
|
1671
|
+
.into_answer(),
|
|
1672
|
+
Ok(Err(ErrorCode::PermanentResolverFailure))
|
|
1673
|
+
),
|
|
1674
|
+
"resolve-addresses with no network entry must answer permanent-resolver-failure"
|
|
1675
|
+
);
|
|
1676
|
+
}
|
|
1677
|
+
|
|
1678
|
+
// @behavior NW-197
|
|
1679
|
+
#[test]
|
|
1680
|
+
fn a_name_no_url_host_spells_is_refused_as_an_invalid_argument() {
|
|
1681
|
+
let mut guest = network_guest(network::Endpoint::new("*.example.com", 443).unwrap());
|
|
1682
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
1683
|
+
let answers = [
|
|
1684
|
+
"xn--a",
|
|
1685
|
+
"a\\.example.com",
|
|
1686
|
+
"a b.example.com",
|
|
1687
|
+
"a/b.example.com",
|
|
1688
|
+
]
|
|
1689
|
+
.map(|name| {
|
|
1690
|
+
matches!(
|
|
1691
|
+
guest
|
|
1692
|
+
.ip_name_lookup_resolve_addresses(network, name.to_string())
|
|
1693
|
+
.into_answer(),
|
|
1694
|
+
Ok(Err(ErrorCode::InvalidArgument))
|
|
1695
|
+
)
|
|
1696
|
+
});
|
|
1697
|
+
assert_eq!(
|
|
1698
|
+
answers, [true; 4],
|
|
1699
|
+
"resolve-addresses of xn--a, which no A-label spells, and of names beneath \
|
|
1700
|
+
*.example.com holding a backslash, a space, or a slash must each answer \
|
|
1701
|
+
invalid-argument before any query"
|
|
1702
|
+
);
|
|
1703
|
+
}
|
|
1704
|
+
|
|
1705
|
+
// @behavior NW-201
|
|
1706
|
+
#[test]
|
|
1707
|
+
fn a_lookup_of_an_address_answers_the_address_itself() {
|
|
1708
|
+
let mut guest = network_guest(network::Endpoint::new("example.com", 443).unwrap());
|
|
1709
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
1710
|
+
let mut answer_of = |name: &str| -> Vec<IpAddress> {
|
|
1711
|
+
let stream = guest
|
|
1712
|
+
.ip_name_lookup_resolve_addresses(network, name.to_string())
|
|
1713
|
+
.into_answer()
|
|
1714
|
+
.unwrap()
|
|
1715
|
+
.expect("an address needs no endpoint to be looked up");
|
|
1716
|
+
let mut answered = Vec::new();
|
|
1717
|
+
while let Some(address) = guest
|
|
1718
|
+
.ip_name_lookup_resolve_address_stream_resolve_next_address(stream)
|
|
1719
|
+
.into_answer()
|
|
1720
|
+
.unwrap()
|
|
1721
|
+
.expect("an address answers at once, with no query")
|
|
1722
|
+
{
|
|
1723
|
+
answered.push(address);
|
|
1724
|
+
}
|
|
1725
|
+
answered
|
|
1726
|
+
};
|
|
1727
|
+
assert_eq!(
|
|
1728
|
+
[
|
|
1729
|
+
answer_of("10.1.2.3"),
|
|
1730
|
+
answer_of("127.1"),
|
|
1731
|
+
answer_of("0x7f.1"),
|
|
1732
|
+
answer_of("::1"),
|
|
1733
|
+
answer_of("::ffff:10.1.2.3"),
|
|
1734
|
+
],
|
|
1735
|
+
[
|
|
1736
|
+
vec![IpAddress::Ipv4((10, 1, 2, 3))],
|
|
1737
|
+
vec![IpAddress::Ipv4((127, 0, 0, 1))],
|
|
1738
|
+
vec![IpAddress::Ipv4((127, 0, 0, 1))],
|
|
1739
|
+
vec![IpAddress::Ipv6((0, 0, 0, 0, 0, 0, 0, 1))],
|
|
1740
|
+
vec![IpAddress::Ipv4((10, 1, 2, 3))],
|
|
1741
|
+
],
|
|
1742
|
+
"resolve-addresses of an IPv4 address in full and in a short form, and of a bare \
|
|
1743
|
+
IPv6 address, must each answer the address it spells, and an IPv4-mapped IPv6 \
|
|
1744
|
+
address its IPv4 address"
|
|
1745
|
+
);
|
|
1746
|
+
}
|
|
1747
|
+
|
|
1748
|
+
// @behavior NW-031
|
|
1749
|
+
#[test]
|
|
1750
|
+
fn a_looked_up_name_connects_and_reads_back_its_virtual_address() {
|
|
1751
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
1752
|
+
let port = listener.local_addr().unwrap().port();
|
|
1753
|
+
let mut guest = network_guest(
|
|
1754
|
+
network::Endpoint::new("localhost", port)
|
|
1755
|
+
.unwrap()
|
|
1756
|
+
.with_protocol(network::Protocol::Tcp)
|
|
1757
|
+
.with_addresses(vec![network::Addresses::Local]),
|
|
1758
|
+
);
|
|
1759
|
+
let started = Instant::now();
|
|
1760
|
+
let (handed, connected) = run_task(Some(started + Duration::from_secs(10)), || {
|
|
1761
|
+
let network = guest.instance_network_instance_network()?;
|
|
1762
|
+
let stream = guest
|
|
1763
|
+
.ip_name_lookup_resolve_addresses(network, "localhost".to_string())
|
|
1764
|
+
.into_answer()?
|
|
1765
|
+
.expect("an endpoint names the name");
|
|
1766
|
+
let answered = guest.ip_name_lookup_resolve_address_stream_subscribe(stream)?;
|
|
1767
|
+
guest.poll_pollable_block(answered)?;
|
|
1768
|
+
let mut handed = Vec::new();
|
|
1769
|
+
while let Some(IpAddress::Ipv4(address)) = guest
|
|
1770
|
+
.ip_name_lookup_resolve_address_stream_resolve_next_address(stream)
|
|
1771
|
+
.into_answer()?
|
|
1772
|
+
.expect("localhost resolves")
|
|
1773
|
+
{
|
|
1774
|
+
handed.push(address);
|
|
1775
|
+
}
|
|
1776
|
+
// Each virtual address in turn, as a guest tries them, until one
|
|
1777
|
+
// reaches the IPv4 listener.
|
|
1778
|
+
for address in handed.clone() {
|
|
1779
|
+
let socket = guest
|
|
1780
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
1781
|
+
.into_answer()?
|
|
1782
|
+
.expect("a network makes a socket");
|
|
1783
|
+
let remote = ipv4(address, port);
|
|
1784
|
+
if guest
|
|
1785
|
+
.tcp_tcp_socket_start_connect(socket, network, remote)
|
|
1786
|
+
.into_answer()?
|
|
1787
|
+
.is_err()
|
|
1788
|
+
{
|
|
1789
|
+
continue;
|
|
1790
|
+
}
|
|
1791
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
1792
|
+
guest.poll_pollable_block(connecting)?;
|
|
1793
|
+
if guest
|
|
1794
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
1795
|
+
.into_answer()?
|
|
1796
|
+
.is_ok()
|
|
1797
|
+
{
|
|
1798
|
+
let peer = guest.tcp_tcp_socket_remote_address(socket).into_answer()?;
|
|
1799
|
+
return Ok((handed, Some((address, peer))));
|
|
1800
|
+
}
|
|
1801
|
+
}
|
|
1802
|
+
Ok::<_, wasmtime::Error>((handed, None))
|
|
1803
|
+
})
|
|
1804
|
+
.expect("the lookup and the connects answer");
|
|
1805
|
+
let Some((through, peer)) = connected else {
|
|
1806
|
+
panic!("no virtual address localhost answered reached the IPv4 listener: {handed:?}");
|
|
1807
|
+
};
|
|
1808
|
+
assert!(
|
|
1809
|
+
handed.first() == Some(&(198, 18, 0, 0))
|
|
1810
|
+
&& matches!(
|
|
1811
|
+
peer,
|
|
1812
|
+
Ok(IpSocketAddress::Ipv4(Ipv4SocketAddress { address, .. })) if address == through
|
|
1813
|
+
),
|
|
1814
|
+
"a lookup of a name an endpoint names must hand out its virtual addresses from the \
|
|
1815
|
+
bottom of the range, and a socket connected through one must read that virtual \
|
|
1816
|
+
address back as its peer"
|
|
1817
|
+
);
|
|
1818
|
+
}
|
|
1819
|
+
|
|
1820
|
+
// @behavior NW-113
|
|
1821
|
+
#[test]
|
|
1822
|
+
fn a_socket_dropped_while_its_streams_live_traps() {
|
|
1823
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
1824
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
1825
|
+
let (tcp_port, udp_port) = (
|
|
1826
|
+
listener.local_addr().unwrap().port(),
|
|
1827
|
+
peer.local_addr().unwrap().port(),
|
|
1828
|
+
);
|
|
1829
|
+
let mut guest = limited_network_guest(
|
|
1830
|
+
[
|
|
1831
|
+
network::Endpoint::new("127.0.0.1", tcp_port)
|
|
1832
|
+
.unwrap()
|
|
1833
|
+
.with_protocol(network::Protocol::Tcp),
|
|
1834
|
+
network::Endpoint::new("127.0.0.1", udp_port)
|
|
1835
|
+
.unwrap()
|
|
1836
|
+
.with_protocol(network::Protocol::Udp),
|
|
1837
|
+
],
|
|
1838
|
+
None,
|
|
1839
|
+
);
|
|
1840
|
+
let at = |port| ipv4((127, 0, 0, 1), port);
|
|
1841
|
+
let answers = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
1842
|
+
let network = guest.instance_network_instance_network()?;
|
|
1843
|
+
let tcp = guest
|
|
1844
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
1845
|
+
.into_answer()?
|
|
1846
|
+
.expect("a network makes a socket");
|
|
1847
|
+
guest
|
|
1848
|
+
.tcp_tcp_socket_start_connect(tcp, network, at(tcp_port))
|
|
1849
|
+
.into_answer()?
|
|
1850
|
+
.expect("an endpoint names the address");
|
|
1851
|
+
let connecting = guest.tcp_tcp_socket_subscribe(tcp)?;
|
|
1852
|
+
guest.poll_pollable_block(connecting)?;
|
|
1853
|
+
guest.poll_pollable_drop(connecting)?;
|
|
1854
|
+
let (input, output) = guest
|
|
1855
|
+
.tcp_tcp_socket_finish_connect(tcp)
|
|
1856
|
+
.into_answer()?
|
|
1857
|
+
.expect("the listener accepts");
|
|
1858
|
+
let streams_held = guest.tcp_tcp_socket_drop(tcp).is_err();
|
|
1859
|
+
guest.streams_input_stream_drop(input)?;
|
|
1860
|
+
guest.streams_output_stream_drop(output)?;
|
|
1861
|
+
let ready = guest.tcp_tcp_socket_subscribe(tcp)?;
|
|
1862
|
+
let pollable_held = guest.tcp_tcp_socket_drop(tcp).is_err();
|
|
1863
|
+
guest.poll_pollable_drop(ready)?;
|
|
1864
|
+
let tcp_late = guest.tcp_tcp_socket_drop(tcp).is_ok();
|
|
1865
|
+
|
|
1866
|
+
let udp = guest
|
|
1867
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
1868
|
+
.into_answer()?
|
|
1869
|
+
.expect("a network makes a socket");
|
|
1870
|
+
let any = ipv4((0, 0, 0, 0), 0);
|
|
1871
|
+
guest
|
|
1872
|
+
.udp_udp_socket_start_bind(udp, network, any)
|
|
1873
|
+
.into_answer()?
|
|
1874
|
+
.expect("an ephemeral bind is the implicit one");
|
|
1875
|
+
guest
|
|
1876
|
+
.udp_udp_socket_finish_bind(udp)
|
|
1877
|
+
.into_answer()?
|
|
1878
|
+
.expect("the bind settles");
|
|
1879
|
+
let (incoming, outgoing) = guest
|
|
1880
|
+
.udp_udp_socket_stream(udp, Some(at(udp_port)))
|
|
1881
|
+
.into_answer()?
|
|
1882
|
+
.expect("the udp endpoint names the peer");
|
|
1883
|
+
let again_early = guest
|
|
1884
|
+
.udp_udp_socket_stream(udp, Some(at(udp_port)))
|
|
1885
|
+
.into_answer()
|
|
1886
|
+
.is_err();
|
|
1887
|
+
let udp_early = guest.udp_udp_socket_drop(udp).is_err();
|
|
1888
|
+
guest.udp_incoming_datagram_stream_drop(incoming)?;
|
|
1889
|
+
guest.udp_outgoing_datagram_stream_drop(outgoing)?;
|
|
1890
|
+
let again_late = guest
|
|
1891
|
+
.udp_udp_socket_stream(udp, Some(at(udp_port)))
|
|
1892
|
+
.into_answer()?
|
|
1893
|
+
.map(|(incoming, outgoing)| {
|
|
1894
|
+
guest.udp_incoming_datagram_stream_drop(incoming)?;
|
|
1895
|
+
guest.udp_outgoing_datagram_stream_drop(outgoing)
|
|
1896
|
+
})
|
|
1897
|
+
.is_ok_and(|dropped| dropped.is_ok());
|
|
1898
|
+
let udp_late = guest.udp_udp_socket_drop(udp).is_ok();
|
|
1899
|
+
Ok::<_, wasmtime::Error>([
|
|
1900
|
+
streams_held,
|
|
1901
|
+
pollable_held,
|
|
1902
|
+
tcp_late,
|
|
1903
|
+
again_early,
|
|
1904
|
+
udp_early,
|
|
1905
|
+
again_late,
|
|
1906
|
+
udp_late,
|
|
1907
|
+
])
|
|
1908
|
+
})
|
|
1909
|
+
.expect("the sockets connect");
|
|
1910
|
+
assert_eq!(
|
|
1911
|
+
answers, [true; 7],
|
|
1912
|
+
"a tcp-socket or udp-socket dropped while its streams or pollable live, and a second \
|
|
1913
|
+
udp stream while the first lives, must trap as wasmtime-wasi traps them, and each \
|
|
1914
|
+
must succeed once the children are dropped"
|
|
1915
|
+
);
|
|
1916
|
+
}
|
|
1917
|
+
|
|
1918
|
+
// @behavior NW-194
|
|
1919
|
+
#[test]
|
|
1920
|
+
fn a_bind_to_port_zero_takes_a_free_virtual_port() {
|
|
1921
|
+
let mut guest = network_guest(network::Endpoint::new("127.0.0.1", 9).unwrap());
|
|
1922
|
+
let answers = (|| {
|
|
1923
|
+
let network = guest.instance_network_instance_network()?;
|
|
1924
|
+
// A TCP socket's local-address once bound to 0.0.0.0 port 0.
|
|
1925
|
+
let bound_tcp = |guest: &mut Invocation| {
|
|
1926
|
+
let tcp = guest
|
|
1927
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
1928
|
+
.into_answer()?
|
|
1929
|
+
.expect("a network makes a socket");
|
|
1930
|
+
guest
|
|
1931
|
+
.tcp_tcp_socket_start_bind(tcp, network, ipv4((0, 0, 0, 0), 0))
|
|
1932
|
+
.into_answer()?
|
|
1933
|
+
.expect("a bind to port 0 takes a free port");
|
|
1934
|
+
guest
|
|
1935
|
+
.tcp_tcp_socket_finish_bind(tcp)
|
|
1936
|
+
.into_answer()?
|
|
1937
|
+
.expect("the bind settles");
|
|
1938
|
+
guest.tcp_tcp_socket_local_address(tcp).into_answer()
|
|
1939
|
+
};
|
|
1940
|
+
let tcp_end = bound_tcp(&mut guest)?;
|
|
1941
|
+
let udp = guest
|
|
1942
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
1943
|
+
.into_answer()?
|
|
1944
|
+
.expect("a network makes a socket");
|
|
1945
|
+
guest
|
|
1946
|
+
.udp_udp_socket_start_bind(udp, network, ipv4((0, 0, 0, 0), 0))
|
|
1947
|
+
.into_answer()?
|
|
1948
|
+
.expect("a bind to port 0 takes a free port");
|
|
1949
|
+
guest
|
|
1950
|
+
.udp_udp_socket_finish_bind(udp)
|
|
1951
|
+
.into_answer()?
|
|
1952
|
+
.expect("the bind settles");
|
|
1953
|
+
let udp_end = guest.udp_udp_socket_local_address(udp).into_answer()?;
|
|
1954
|
+
let other_end = bound_tcp(&mut guest)?;
|
|
1955
|
+
Ok::<_, wasmtime::Error>((tcp_end, udp_end, other_end))
|
|
1956
|
+
})()
|
|
1957
|
+
.unwrap();
|
|
1958
|
+
assert_eq!(
|
|
1959
|
+
answers,
|
|
1960
|
+
(
|
|
1961
|
+
Ok(ipv4((0, 0, 0, 0), 32768)),
|
|
1962
|
+
Ok(ipv4((0, 0, 0, 0), 32768)),
|
|
1963
|
+
Ok(ipv4((0, 0, 0, 0), 32769))
|
|
1964
|
+
),
|
|
1965
|
+
"a TCP and a UDP socket bound to 0.0.0.0 port 0 must each read 0.0.0.0 and the first \
|
|
1966
|
+
virtual port as their local-address, each protocol holding its own ports, and a \
|
|
1967
|
+
second TCP socket the next port, as inet_csk_get_port takes a free one"
|
|
1968
|
+
);
|
|
1969
|
+
}
|
|
1970
|
+
|
|
1971
|
+
// @behavior NW-153
|
|
1972
|
+
#[test]
|
|
1973
|
+
fn a_udp_socket_answers_bound_and_empty_sends_as_wasmtimes() {
|
|
1974
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
1975
|
+
let port = peer.local_addr().unwrap().port();
|
|
1976
|
+
let mut guest = network_guest(
|
|
1977
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
1978
|
+
.unwrap()
|
|
1979
|
+
.with_protocol(network::Protocol::Udp),
|
|
1980
|
+
);
|
|
1981
|
+
let answers = (|| {
|
|
1982
|
+
let network = guest.instance_network_instance_network()?;
|
|
1983
|
+
let udp = guest
|
|
1984
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
1985
|
+
.into_answer()?
|
|
1986
|
+
.expect("a network makes a socket");
|
|
1987
|
+
guest
|
|
1988
|
+
.udp_udp_socket_start_bind(udp, network, ipv4((0, 0, 0, 0), 0))
|
|
1989
|
+
.into_answer()?
|
|
1990
|
+
.expect("an ephemeral bind is the implicit one");
|
|
1991
|
+
let binding = guest.udp_udp_socket_local_address(udp).into_answer()?.ok();
|
|
1992
|
+
guest
|
|
1993
|
+
.udp_udp_socket_finish_bind(udp)
|
|
1994
|
+
.into_answer()?
|
|
1995
|
+
.expect("the bind settles");
|
|
1996
|
+
let bound = guest
|
|
1997
|
+
.udp_udp_socket_local_address(udp)
|
|
1998
|
+
.into_answer()?
|
|
1999
|
+
.expect("a bound socket answers its address");
|
|
2000
|
+
let (_, outgoing) = guest
|
|
2001
|
+
.udp_udp_socket_stream(udp, Some(ipv4((127, 0, 0, 1), port)))
|
|
2002
|
+
.into_answer()?
|
|
2003
|
+
.expect("the udp endpoint names the peer");
|
|
2004
|
+
let permitted = guest
|
|
2005
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
2006
|
+
.into_answer()?
|
|
2007
|
+
.expect("a streaming socket permits");
|
|
2008
|
+
let empty = guest
|
|
2009
|
+
.udp_outgoing_datagram_stream_send(outgoing, Vec::new())
|
|
2010
|
+
.into_answer()?
|
|
2011
|
+
.ok();
|
|
2012
|
+
let kept = guest
|
|
2013
|
+
.udp_outgoing_datagram_stream_send(
|
|
2014
|
+
outgoing,
|
|
2015
|
+
vec![OutgoingDatagram {
|
|
2016
|
+
data: b"x".to_vec(),
|
|
2017
|
+
remote_address: None,
|
|
2018
|
+
}],
|
|
2019
|
+
)
|
|
2020
|
+
.into_answer()?
|
|
2021
|
+
.ok();
|
|
2022
|
+
let ephemeral = match bound {
|
|
2023
|
+
IpSocketAddress::Ipv4(Ipv4SocketAddress { port, .. }) => port,
|
|
2024
|
+
IpSocketAddress::Ipv6(_) => 0,
|
|
2025
|
+
};
|
|
2026
|
+
Ok::<_, wasmtime::Error>((binding, ephemeral, bound, permitted > 0, empty, kept))
|
|
2027
|
+
})()
|
|
2028
|
+
.expect("the socket streams");
|
|
2029
|
+
let (binding, ephemeral, bound, permitted, empty, kept) = answers;
|
|
2030
|
+
assert_eq!(
|
|
2031
|
+
(binding, ephemeral > 0, bound, permitted, empty, kept),
|
|
2032
|
+
(
|
|
2033
|
+
Some(ipv4((0, 0, 0, 0), ephemeral)),
|
|
2034
|
+
true,
|
|
2035
|
+
ipv4((0, 0, 0, 0), ephemeral),
|
|
2036
|
+
true,
|
|
2037
|
+
Some(0),
|
|
2038
|
+
Some(1)
|
|
2039
|
+
),
|
|
2040
|
+
"a UDP socket must answer local-address once its bind of 0.0.0.0:0 began, as the \
|
|
2041
|
+
address and ephemeral port its finished bind answers, and an empty send must answer \
|
|
2042
|
+
0 without spending check-send's permit, as wasmtime-wasi answers both"
|
|
2043
|
+
);
|
|
2044
|
+
}
|
|
2045
|
+
|
|
2046
|
+
// @behavior NW-147
|
|
2047
|
+
#[test]
|
|
2048
|
+
fn a_producer_dropped_while_its_pollable_lives_traps() {
|
|
2049
|
+
use super::super::bindings::wasi_http_types_0_2_12::Scheme;
|
|
2050
|
+
use super::super::bindings::HttpHost;
|
|
2051
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2052
|
+
let udp_port = peer.local_addr().unwrap().port();
|
|
2053
|
+
let mut guest = limited_network_guest(
|
|
2054
|
+
[
|
|
2055
|
+
network::Endpoint::new("127.0.0.1", udp_port)
|
|
2056
|
+
.unwrap()
|
|
2057
|
+
.with_protocol(network::Protocol::Udp),
|
|
2058
|
+
network::Endpoint::new("localhost", 80)
|
|
2059
|
+
.unwrap()
|
|
2060
|
+
.with_addresses(vec![network::Addresses::Local]),
|
|
2061
|
+
],
|
|
2062
|
+
None,
|
|
2063
|
+
);
|
|
2064
|
+
let answers = (|| {
|
|
2065
|
+
let network = guest.instance_network_instance_network()?;
|
|
2066
|
+
let udp = guest
|
|
2067
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2068
|
+
.into_answer()?
|
|
2069
|
+
.expect("a network makes a socket");
|
|
2070
|
+
let any = ipv4((0, 0, 0, 0), 0);
|
|
2071
|
+
guest
|
|
2072
|
+
.udp_udp_socket_start_bind(udp, network, any)
|
|
2073
|
+
.into_answer()?
|
|
2074
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2075
|
+
guest
|
|
2076
|
+
.udp_udp_socket_finish_bind(udp)
|
|
2077
|
+
.into_answer()?
|
|
2078
|
+
.expect("the bind settles");
|
|
2079
|
+
let peer_at = ipv4((127, 0, 0, 1), udp_port);
|
|
2080
|
+
let (incoming, outgoing) = guest
|
|
2081
|
+
.udp_udp_socket_stream(udp, Some(peer_at))
|
|
2082
|
+
.into_answer()?
|
|
2083
|
+
.expect("the udp endpoint names the peer");
|
|
2084
|
+
let readable = guest.udp_incoming_datagram_stream_subscribe(incoming)?;
|
|
2085
|
+
let writable = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
2086
|
+
let datagrams_held = guest.udp_incoming_datagram_stream_drop(incoming).is_err()
|
|
2087
|
+
&& guest.udp_outgoing_datagram_stream_drop(outgoing).is_err();
|
|
2088
|
+
guest.poll_pollable_drop(readable)?;
|
|
2089
|
+
guest.poll_pollable_drop(writable)?;
|
|
2090
|
+
let datagrams_late = guest.udp_incoming_datagram_stream_drop(incoming).is_ok()
|
|
2091
|
+
&& guest.udp_outgoing_datagram_stream_drop(outgoing).is_ok();
|
|
2092
|
+
|
|
2093
|
+
let lookup = guest
|
|
2094
|
+
.ip_name_lookup_resolve_addresses(network, "localhost".to_string())
|
|
2095
|
+
.into_answer()?
|
|
2096
|
+
.expect("an endpoint names localhost");
|
|
2097
|
+
let resolved = guest.ip_name_lookup_resolve_address_stream_subscribe(lookup)?;
|
|
2098
|
+
let lookup_held = guest
|
|
2099
|
+
.ip_name_lookup_resolve_address_stream_drop(lookup)
|
|
2100
|
+
.is_err();
|
|
2101
|
+
guest.poll_pollable_drop(resolved)?;
|
|
2102
|
+
let lookup_late = guest
|
|
2103
|
+
.ip_name_lookup_resolve_address_stream_drop(lookup)
|
|
2104
|
+
.is_ok();
|
|
2105
|
+
|
|
2106
|
+
let headers = guest.types_fields_new()?;
|
|
2107
|
+
let headers = guest.take_handle(headers)?;
|
|
2108
|
+
let request = guest.types_outgoing_request_new(headers)?;
|
|
2109
|
+
guest
|
|
2110
|
+
.types_outgoing_request_set_scheme(request, Some(Scheme::HTTP))?
|
|
2111
|
+
.expect("http is a scheme");
|
|
2112
|
+
guest
|
|
2113
|
+
.types_outgoing_request_set_authority(request, Some("other.test".to_string()))?
|
|
2114
|
+
.expect("an authority");
|
|
2115
|
+
let body = guest
|
|
2116
|
+
.types_outgoing_request_body(request)?
|
|
2117
|
+
.expect("a request hands out its body once");
|
|
2118
|
+
let request = guest.take_handle(request)?;
|
|
2119
|
+
let future = guest
|
|
2120
|
+
.outgoing_handler_handle(request, None)
|
|
2121
|
+
.into_answer()?
|
|
2122
|
+
.expect("a request whose body is unfinished waits in its future");
|
|
2123
|
+
guest.types_outgoing_body_drop(body)?;
|
|
2124
|
+
let arrived = guest.types_future_incoming_response_subscribe(future)?;
|
|
2125
|
+
let future_held = guest.types_future_incoming_response_drop(future).is_err();
|
|
2126
|
+
guest.poll_pollable_drop(arrived)?;
|
|
2127
|
+
let future_late = guest.types_future_incoming_response_drop(future).is_ok();
|
|
2128
|
+
Ok::<_, wasmtime::Error>([
|
|
2129
|
+
datagrams_held,
|
|
2130
|
+
datagrams_late,
|
|
2131
|
+
lookup_held,
|
|
2132
|
+
lookup_late,
|
|
2133
|
+
future_held,
|
|
2134
|
+
future_late,
|
|
2135
|
+
])
|
|
2136
|
+
})()
|
|
2137
|
+
.expect("the producers are made");
|
|
2138
|
+
assert_eq!(
|
|
2139
|
+
answers, [true; 6],
|
|
2140
|
+
"a datagram stream, a resolve-address-stream, or a future-incoming-response dropped \
|
|
2141
|
+
while its pollable lives must trap, as wasmtime-wasi makes every pollable a child, \
|
|
2142
|
+
and each must drop once its pollable is gone"
|
|
2143
|
+
);
|
|
2144
|
+
}
|
|
2145
|
+
|
|
2146
|
+
// @behavior NW-114
|
|
2147
|
+
#[test]
|
|
2148
|
+
fn a_tcp_socket_reads_its_own_end_only_once_connected() {
|
|
2149
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
2150
|
+
let open = listener.local_addr().unwrap().port();
|
|
2151
|
+
let closed = std::net::TcpListener::bind("127.0.0.1:0")
|
|
2152
|
+
.unwrap()
|
|
2153
|
+
.local_addr()
|
|
2154
|
+
.unwrap()
|
|
2155
|
+
.port();
|
|
2156
|
+
let tcp = |port| {
|
|
2157
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
2158
|
+
.unwrap()
|
|
2159
|
+
.with_protocol(network::Protocol::Tcp)
|
|
2160
|
+
};
|
|
2161
|
+
let mut guest = limited_network_guest([tcp(open), tcp(closed)], None);
|
|
2162
|
+
let (during, failure, after) =
|
|
2163
|
+
run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2164
|
+
let network = guest.instance_network_instance_network()?;
|
|
2165
|
+
let connecting = guest
|
|
2166
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2167
|
+
.into_answer()?
|
|
2168
|
+
.expect("a network makes a socket");
|
|
2169
|
+
guest
|
|
2170
|
+
.tcp_tcp_socket_start_connect(connecting, network, ipv4((127, 0, 0, 1), open))
|
|
2171
|
+
.into_answer()?
|
|
2172
|
+
.expect("an endpoint names the listener");
|
|
2173
|
+
let during = guest
|
|
2174
|
+
.tcp_tcp_socket_local_address(connecting)
|
|
2175
|
+
.into_answer()?;
|
|
2176
|
+
let refused = guest
|
|
2177
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2178
|
+
.into_answer()?
|
|
2179
|
+
.expect("a network makes a socket");
|
|
2180
|
+
guest
|
|
2181
|
+
.tcp_tcp_socket_start_connect(refused, network, ipv4((127, 0, 0, 1), closed))
|
|
2182
|
+
.into_answer()?
|
|
2183
|
+
.expect("an endpoint names the closed port");
|
|
2184
|
+
let settled = guest.tcp_tcp_socket_subscribe(refused)?;
|
|
2185
|
+
guest.poll_pollable_block(settled)?;
|
|
2186
|
+
let failure = guest
|
|
2187
|
+
.tcp_tcp_socket_finish_connect(refused)
|
|
2188
|
+
.into_answer()?
|
|
2189
|
+
.err();
|
|
2190
|
+
let after = (
|
|
2191
|
+
guest.tcp_tcp_socket_local_address(refused).into_answer()?,
|
|
2192
|
+
guest
|
|
2193
|
+
.tcp_tcp_socket_remote_address(refused)
|
|
2194
|
+
.into_answer()?
|
|
2195
|
+
.err(),
|
|
2196
|
+
);
|
|
2197
|
+
Ok::<_, wasmtime::Error>((during, failure, after))
|
|
2198
|
+
})
|
|
2199
|
+
.expect("the connects answer");
|
|
2200
|
+
assert_eq!(
|
|
2201
|
+
(during, failure, after),
|
|
2202
|
+
(
|
|
2203
|
+
Err(ErrorCode::InvalidState),
|
|
2204
|
+
Some(ErrorCode::ConnectionRefused),
|
|
2205
|
+
(
|
|
2206
|
+
Err(ErrorCode::ConnectionRefused),
|
|
2207
|
+
Some(ErrorCode::ConnectionRefused)
|
|
2208
|
+
)
|
|
2209
|
+
),
|
|
2210
|
+
"local-address of a TCP socket still connecting must answer invalid-state, and \
|
|
2211
|
+
local-address and remote-address of one whose connect was refused the connect's \
|
|
2212
|
+
error, as wasmtime-wasi answers each"
|
|
2213
|
+
);
|
|
2214
|
+
}
|
|
2215
|
+
|
|
2216
|
+
// @behavior NW-167
|
|
2217
|
+
#[test]
|
|
2218
|
+
fn a_tcp_socket_whose_connect_failed_connects_no_more() {
|
|
2219
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
2220
|
+
let port = listener.local_addr().unwrap().port();
|
|
2221
|
+
let mut guest = network_guest(network::Endpoint::new("127.0.0.1", port).unwrap());
|
|
2222
|
+
let answers = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2223
|
+
let network = guest.instance_network_instance_network()?;
|
|
2224
|
+
let socket = guest
|
|
2225
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2226
|
+
.into_answer()?
|
|
2227
|
+
.expect("a network makes a socket");
|
|
2228
|
+
let started = guest
|
|
2229
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port ^ 1))
|
|
2230
|
+
.into_answer()?;
|
|
2231
|
+
let refused = guest
|
|
2232
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
2233
|
+
.into_answer()?
|
|
2234
|
+
.map(drop);
|
|
2235
|
+
let again = guest
|
|
2236
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
2237
|
+
.into_answer()?;
|
|
2238
|
+
Ok::<_, wasmtime::Error>((started, refused, again))
|
|
2239
|
+
})
|
|
2240
|
+
.expect("the calls answer");
|
|
2241
|
+
assert_eq!(
|
|
2242
|
+
answers,
|
|
2243
|
+
(
|
|
2244
|
+
Ok(()),
|
|
2245
|
+
Err(ErrorCode::AccessDenied),
|
|
2246
|
+
Err(ErrorCode::InvalidState)
|
|
2247
|
+
),
|
|
2248
|
+
"a TCP socket's start-connect no endpoint allows must succeed and its finish-connect \
|
|
2249
|
+
answer access-denied, as wasmtime-wasi's connect fails once under way, and a later \
|
|
2250
|
+
connect it would allow invalid-state, as sockets.wit closes a socket after a failed \
|
|
2251
|
+
connection attempt"
|
|
2252
|
+
);
|
|
2253
|
+
}
|
|
2254
|
+
|
|
2255
|
+
// @behavior NW-166
|
|
2256
|
+
#[test]
|
|
2257
|
+
fn a_udp_stream_leaves_a_bind_under_way_standing() {
|
|
2258
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2259
|
+
let port = peer.local_addr().unwrap().port();
|
|
2260
|
+
let mut guest = network_guest(
|
|
2261
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
2262
|
+
.unwrap()
|
|
2263
|
+
.with_protocol(network::Protocol::Udp),
|
|
2264
|
+
);
|
|
2265
|
+
let answers = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2266
|
+
let network = guest.instance_network_instance_network()?;
|
|
2267
|
+
let socket = guest
|
|
2268
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2269
|
+
.into_answer()?
|
|
2270
|
+
.expect("a network makes a socket");
|
|
2271
|
+
guest
|
|
2272
|
+
.udp_udp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
2273
|
+
.into_answer()?
|
|
2274
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2275
|
+
guest
|
|
2276
|
+
.udp_udp_socket_stream(socket, Some(ipv4((127, 0, 0, 1), port)))
|
|
2277
|
+
.into_answer()?
|
|
2278
|
+
.expect("a socket whose bind began streams");
|
|
2279
|
+
let again = guest
|
|
2280
|
+
.udp_udp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
2281
|
+
.into_answer()?;
|
|
2282
|
+
let finished = guest.udp_udp_socket_finish_bind(socket).into_answer()?;
|
|
2283
|
+
Ok::<_, wasmtime::Error>((again, finished))
|
|
2284
|
+
})
|
|
2285
|
+
.expect("the calls answer");
|
|
2286
|
+
assert_eq!(
|
|
2287
|
+
answers,
|
|
2288
|
+
(Err(ErrorCode::ConcurrencyConflict), Ok(())),
|
|
2289
|
+
"a UDP socket streaming between start-bind and finish-bind must answer another \
|
|
2290
|
+
start-bind concurrency-conflict and let finish-bind settle, as wasmtime keeps its \
|
|
2291
|
+
bind under way apart from its streams"
|
|
2292
|
+
);
|
|
2293
|
+
}
|
|
2294
|
+
|
|
2295
|
+
// @behavior NW-115
|
|
2296
|
+
#[test]
|
|
2297
|
+
fn one_datagram_receive_answers_at_most_sixteen() {
|
|
2298
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2299
|
+
let port = peer.local_addr().unwrap().port();
|
|
2300
|
+
let mut guest = network_guest(
|
|
2301
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
2302
|
+
.unwrap()
|
|
2303
|
+
.with_protocol(network::Protocol::Udp),
|
|
2304
|
+
);
|
|
2305
|
+
let batches = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2306
|
+
let network = guest.instance_network_instance_network()?;
|
|
2307
|
+
let socket = guest
|
|
2308
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2309
|
+
.into_answer()?
|
|
2310
|
+
.expect("a network makes a socket");
|
|
2311
|
+
guest
|
|
2312
|
+
.udp_udp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
2313
|
+
.into_answer()?
|
|
2314
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2315
|
+
guest
|
|
2316
|
+
.udp_udp_socket_finish_bind(socket)
|
|
2317
|
+
.into_answer()?
|
|
2318
|
+
.expect("the bind settles");
|
|
2319
|
+
let (incoming, outgoing) = guest
|
|
2320
|
+
.udp_udp_socket_stream(socket, Some(ipv4((127, 0, 0, 1), port)))
|
|
2321
|
+
.into_answer()?
|
|
2322
|
+
.expect("the udp endpoint names the peer");
|
|
2323
|
+
let room = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
2324
|
+
guest.poll_pollable_block(room)?;
|
|
2325
|
+
guest
|
|
2326
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
2327
|
+
.into_answer()?
|
|
2328
|
+
.expect("the stream with room permits a datagram");
|
|
2329
|
+
guest
|
|
2330
|
+
.udp_outgoing_datagram_stream_send(
|
|
2331
|
+
outgoing,
|
|
2332
|
+
vec![OutgoingDatagram {
|
|
2333
|
+
data: b"hi".to_vec(),
|
|
2334
|
+
remote_address: None,
|
|
2335
|
+
}],
|
|
2336
|
+
)
|
|
2337
|
+
.into_answer()?
|
|
2338
|
+
.expect("the datagram is sent");
|
|
2339
|
+
let mut buf = [0; 16];
|
|
2340
|
+
let (_, guest_end) = peer.recv_from(&mut buf)?;
|
|
2341
|
+
for _ in 0..20 {
|
|
2342
|
+
peer.send_to(b"ping", guest_end)?;
|
|
2343
|
+
}
|
|
2344
|
+
std::thread::sleep(Duration::from_millis(500));
|
|
2345
|
+
let mut batches = Vec::new();
|
|
2346
|
+
while batches.iter().sum::<usize>() < 20 {
|
|
2347
|
+
let arrived = guest.udp_incoming_datagram_stream_subscribe(incoming)?;
|
|
2348
|
+
guest.poll_pollable_block(arrived)?;
|
|
2349
|
+
guest.poll_pollable_drop(arrived)?;
|
|
2350
|
+
batches.push(
|
|
2351
|
+
guest
|
|
2352
|
+
.udp_incoming_datagram_stream_receive(incoming, 100)
|
|
2353
|
+
.into_answer()?
|
|
2354
|
+
.expect("the peer's datagrams are received")
|
|
2355
|
+
.len(),
|
|
2356
|
+
);
|
|
2357
|
+
}
|
|
2358
|
+
Ok::<_, wasmtime::Error>(batches)
|
|
2359
|
+
})
|
|
2360
|
+
.expect("the datagrams arrive");
|
|
2361
|
+
assert_eq!(
|
|
2362
|
+
batches,
|
|
2363
|
+
[16, 4],
|
|
2364
|
+
"receive with max-results 100 of twenty queued datagrams must answer sixteen, then the \
|
|
2365
|
+
other four, as wasmtime-wasi bounds one receive"
|
|
2366
|
+
);
|
|
2367
|
+
}
|
|
2368
|
+
|
|
2369
|
+
// @behavior NW-221
|
|
2370
|
+
#[test]
|
|
2371
|
+
fn a_datagram_stream_hands_out_only_its_own_peers_datagrams() {
|
|
2372
|
+
let first = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2373
|
+
let second = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2374
|
+
let ports = [&first, &second].map(|peer| peer.local_addr().unwrap().port());
|
|
2375
|
+
let mut guest = limited_network_guest(
|
|
2376
|
+
ports.map(|port| {
|
|
2377
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
2378
|
+
.unwrap()
|
|
2379
|
+
.with_protocol(network::Protocol::Udp)
|
|
2380
|
+
}),
|
|
2381
|
+
None,
|
|
2382
|
+
);
|
|
2383
|
+
let received = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2384
|
+
let network = guest.instance_network_instance_network()?;
|
|
2385
|
+
let socket = guest
|
|
2386
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2387
|
+
.into_answer()?
|
|
2388
|
+
.expect("a network makes a socket");
|
|
2389
|
+
guest
|
|
2390
|
+
.udp_udp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
2391
|
+
.into_answer()?
|
|
2392
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2393
|
+
guest
|
|
2394
|
+
.udp_udp_socket_finish_bind(socket)
|
|
2395
|
+
.into_answer()?
|
|
2396
|
+
.expect("the bind settles");
|
|
2397
|
+
let mut received = Vec::new();
|
|
2398
|
+
for (peer, port) in [&first, &second].into_iter().zip(ports) {
|
|
2399
|
+
let (incoming, outgoing) = guest
|
|
2400
|
+
.udp_udp_socket_stream(socket, Some(ipv4((127, 0, 0, 1), port)))
|
|
2401
|
+
.into_answer()?
|
|
2402
|
+
.expect("the udp endpoint names the peer");
|
|
2403
|
+
let room = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
2404
|
+
guest.poll_pollable_block(room)?;
|
|
2405
|
+
guest.poll_pollable_drop(room)?;
|
|
2406
|
+
guest
|
|
2407
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
2408
|
+
.into_answer()?
|
|
2409
|
+
.expect("the stream with room permits a datagram");
|
|
2410
|
+
guest
|
|
2411
|
+
.udp_outgoing_datagram_stream_send(
|
|
2412
|
+
outgoing,
|
|
2413
|
+
vec![OutgoingDatagram {
|
|
2414
|
+
data: b"hi".to_vec(),
|
|
2415
|
+
remote_address: None,
|
|
2416
|
+
}],
|
|
2417
|
+
)
|
|
2418
|
+
.into_answer()?
|
|
2419
|
+
.expect("the datagram is sent");
|
|
2420
|
+
let mut buf = [0; 16];
|
|
2421
|
+
let (_, guest_end) = peer.recv_from(&mut buf)?;
|
|
2422
|
+
peer.send_to(&port.to_be_bytes(), guest_end)?;
|
|
2423
|
+
// The first peer's datagram is left unread as the socket
|
|
2424
|
+
// moves on; the second stream reads until its own arrives.
|
|
2425
|
+
let arrived = guest.udp_incoming_datagram_stream_subscribe(incoming)?;
|
|
2426
|
+
guest.poll_pollable_block(arrived)?;
|
|
2427
|
+
guest.poll_pollable_drop(arrived)?;
|
|
2428
|
+
while port == ports[1] && received.is_empty() {
|
|
2429
|
+
let arrived = guest.udp_incoming_datagram_stream_subscribe(incoming)?;
|
|
2430
|
+
guest.poll_pollable_block(arrived)?;
|
|
2431
|
+
guest.poll_pollable_drop(arrived)?;
|
|
2432
|
+
received = guest
|
|
2433
|
+
.udp_incoming_datagram_stream_receive(incoming, 100)
|
|
2434
|
+
.into_answer()?
|
|
2435
|
+
.expect("the stream's peer is read");
|
|
2436
|
+
}
|
|
2437
|
+
guest.udp_incoming_datagram_stream_drop(incoming)?;
|
|
2438
|
+
guest.udp_outgoing_datagram_stream_drop(outgoing)?;
|
|
2439
|
+
}
|
|
2440
|
+
Ok::<_, wasmtime::Error>(received)
|
|
2441
|
+
})
|
|
2442
|
+
.expect("the second peer's datagram arrives");
|
|
2443
|
+
assert_eq!(
|
|
2444
|
+
received
|
|
2445
|
+
.iter()
|
|
2446
|
+
.map(|datagram| (
|
|
2447
|
+
datagram.data.clone(),
|
|
2448
|
+
format!("{:?}", datagram.remote_address)
|
|
2449
|
+
))
|
|
2450
|
+
.collect::<Vec<_>>(),
|
|
2451
|
+
[(
|
|
2452
|
+
ports[1].to_be_bytes().to_vec(),
|
|
2453
|
+
format!("{:?}", ipv4((127, 0, 0, 1), ports[1]))
|
|
2454
|
+
)],
|
|
2455
|
+
"a datagram stream made with a second peer must hand out that peer's datagram alone, \
|
|
2456
|
+
dropping the one the first peer sent before, as wasmtime-wasi limits a stream to \
|
|
2457
|
+
the peer it was made with"
|
|
2458
|
+
);
|
|
2459
|
+
}
|
|
2460
|
+
|
|
2461
|
+
// @behavior NW-055
|
|
2462
|
+
#[test]
|
|
2463
|
+
fn a_udp_socket_streams_only_with_a_peer_it_names() {
|
|
2464
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
2465
|
+
peer.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
|
|
2466
|
+
let port = peer.local_addr().unwrap().port();
|
|
2467
|
+
let mut guest = network_guest(
|
|
2468
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
2469
|
+
.unwrap()
|
|
2470
|
+
.with_protocol(network::Protocol::Udp),
|
|
2471
|
+
);
|
|
2472
|
+
let at = |port| ipv4((127, 0, 0, 1), port);
|
|
2473
|
+
let any = |port| ipv4((0, 0, 0, 0), port);
|
|
2474
|
+
let started = Instant::now();
|
|
2475
|
+
let (fixed, peerless, answer) = run_task(Some(started + Duration::from_secs(10)), || {
|
|
2476
|
+
let network = guest.instance_network_instance_network()?;
|
|
2477
|
+
let fixed_socket = guest
|
|
2478
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2479
|
+
.into_answer()?
|
|
2480
|
+
.expect("a network makes a socket");
|
|
2481
|
+
let fixed = guest
|
|
2482
|
+
.udp_udp_socket_start_bind(fixed_socket, network, any(4000))
|
|
2483
|
+
.into_answer()?;
|
|
2484
|
+
let socket = guest
|
|
2485
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2486
|
+
.into_answer()?
|
|
2487
|
+
.expect("a network makes a socket");
|
|
2488
|
+
guest
|
|
2489
|
+
.udp_udp_socket_start_bind(socket, network, any(0))
|
|
2490
|
+
.into_answer()?
|
|
2491
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2492
|
+
guest
|
|
2493
|
+
.udp_udp_socket_finish_bind(socket)
|
|
2494
|
+
.into_answer()?
|
|
2495
|
+
.expect("the bind settles");
|
|
2496
|
+
let peerless = guest
|
|
2497
|
+
.udp_udp_socket_stream(socket, None)
|
|
2498
|
+
.into_answer()?
|
|
2499
|
+
.map(drop);
|
|
2500
|
+
let (incoming, outgoing) = guest
|
|
2501
|
+
.udp_udp_socket_stream(socket, Some(at(port)))
|
|
2502
|
+
.into_answer()?
|
|
2503
|
+
.expect("the udp endpoint names the peer");
|
|
2504
|
+
let room = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
2505
|
+
guest.poll_pollable_block(room)?;
|
|
2506
|
+
guest
|
|
2507
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
2508
|
+
.into_answer()?
|
|
2509
|
+
.expect("the stream with room permits a datagram");
|
|
2510
|
+
let sent = guest.udp_outgoing_datagram_stream_send(
|
|
2511
|
+
outgoing,
|
|
2512
|
+
vec![OutgoingDatagram {
|
|
2513
|
+
data: b"ping".to_vec(),
|
|
2514
|
+
remote_address: None,
|
|
2515
|
+
}],
|
|
2516
|
+
);
|
|
2517
|
+
if !matches!(sent, Ok(1)) {
|
|
2518
|
+
return Err(wasmtime::Error::msg("the datagram was not sent"));
|
|
2519
|
+
}
|
|
2520
|
+
let mut buf = [0; 16];
|
|
2521
|
+
let (n, from) = peer.recv_from(&mut buf)?;
|
|
2522
|
+
peer.send_to(&buf[..n].to_ascii_uppercase(), from)?;
|
|
2523
|
+
let arrived = guest.udp_incoming_datagram_stream_subscribe(incoming)?;
|
|
2524
|
+
guest.poll_pollable_block(arrived)?;
|
|
2525
|
+
let answer = guest
|
|
2526
|
+
.udp_incoming_datagram_stream_receive(incoming, 4)
|
|
2527
|
+
.into_answer()?
|
|
2528
|
+
.expect("the peer's datagram is received");
|
|
2529
|
+
Ok((fixed, peerless, answer))
|
|
2530
|
+
})
|
|
2531
|
+
.expect("the bind, the stream, and the round trip answer");
|
|
2532
|
+
assert!(
|
|
2533
|
+
matches!(fixed, Err(ErrorCode::AccessDenied))
|
|
2534
|
+
&& matches!(peerless, Err(ErrorCode::AccessDenied))
|
|
2535
|
+
&& answer.len() == 1
|
|
2536
|
+
&& answer[0].data == b"PING"
|
|
2537
|
+
&& matches!(
|
|
2538
|
+
answer[0].remote_address,
|
|
2539
|
+
IpSocketAddress::Ipv4(Ipv4SocketAddress {
|
|
2540
|
+
address: (127, 0, 0, 1),
|
|
2541
|
+
port: p,
|
|
2542
|
+
}) if p == port
|
|
2543
|
+
),
|
|
2544
|
+
"a UDP socket must refuse a fixed-port bind and a stream with no peer as \
|
|
2545
|
+
access-denied, and carry a datagram both ways with the peer a udp endpoint names; \
|
|
2546
|
+
got bind {fixed:?}, peerless {peerless:?}, received {} datagram(s)",
|
|
2547
|
+
answer.len()
|
|
2548
|
+
);
|
|
2549
|
+
}
|
|
2550
|
+
|
|
2551
|
+
fn ipv4(address: (u8, u8, u8, u8), port: u16) -> IpSocketAddress {
|
|
2552
|
+
IpSocketAddress::Ipv4(Ipv4SocketAddress { port, address })
|
|
2553
|
+
}
|
|
2554
|
+
|
|
2555
|
+
/// A guest whose network reaches a loopback listener over TCP and UDP,
|
|
2556
|
+
/// and the listener's port.
|
|
2557
|
+
fn guest_and_listener() -> (Invocation, std::net::TcpListener) {
|
|
2558
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
2559
|
+
let port = listener.local_addr().unwrap().port();
|
|
2560
|
+
let endpoint = network::Endpoint::new("127.0.0.1", port)
|
|
2561
|
+
.unwrap()
|
|
2562
|
+
.with_protocol(network::Protocol::Tcp)
|
|
2563
|
+
.with_addresses(vec![network::Addresses::Local]);
|
|
2564
|
+
(network_guest(endpoint), listener)
|
|
2565
|
+
}
|
|
2566
|
+
|
|
2567
|
+
/// A TCP socket of `guest`'s connected to the loopback listener at
|
|
2568
|
+
/// `port`, and its streams.
|
|
2569
|
+
fn connect_loopback(
|
|
2570
|
+
guest: &mut Invocation,
|
|
2571
|
+
network: Network,
|
|
2572
|
+
port: u16,
|
|
2573
|
+
) -> wasmtime::Result<(TcpSocket, InputStream, OutputStream)> {
|
|
2574
|
+
let socket = guest
|
|
2575
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2576
|
+
.into_answer()?
|
|
2577
|
+
.expect("a network makes a socket");
|
|
2578
|
+
guest
|
|
2579
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
2580
|
+
.into_answer()?
|
|
2581
|
+
.expect("the endpoint names the listener");
|
|
2582
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
2583
|
+
guest.poll_pollable_block(connecting)?;
|
|
2584
|
+
let (input, output) = guest
|
|
2585
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
2586
|
+
.into_answer()?
|
|
2587
|
+
.expect("the listener accepts");
|
|
2588
|
+
Ok((socket, input, output))
|
|
2589
|
+
}
|
|
2590
|
+
|
|
2591
|
+
// @behavior NW-202
|
|
2592
|
+
#[test]
|
|
2593
|
+
fn a_tcp_sockets_send_buffer_grows_once_it_connects() {
|
|
2594
|
+
let (mut guest, listener) = guest_and_listener();
|
|
2595
|
+
let port = listener.local_addr().unwrap().port();
|
|
2596
|
+
let sizes = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2597
|
+
let network = guest.instance_network_instance_network()?;
|
|
2598
|
+
let mut sizes = Vec::new();
|
|
2599
|
+
for set in [None, Some(1000)] {
|
|
2600
|
+
let socket = guest
|
|
2601
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2602
|
+
.into_answer()?
|
|
2603
|
+
.expect("a network makes a socket");
|
|
2604
|
+
if let Some(size) = set {
|
|
2605
|
+
guest
|
|
2606
|
+
.tcp_tcp_socket_set_send_buffer_size(socket, size)
|
|
2607
|
+
.into_answer()?
|
|
2608
|
+
.expect("a send buffer size is set");
|
|
2609
|
+
}
|
|
2610
|
+
let read = |guest: &mut Invocation| -> wasmtime::Result<(u64, u64)> {
|
|
2611
|
+
Ok((
|
|
2612
|
+
guest
|
|
2613
|
+
.tcp_tcp_socket_send_buffer_size(socket)
|
|
2614
|
+
.into_answer()?
|
|
2615
|
+
.expect("the size reads"),
|
|
2616
|
+
guest
|
|
2617
|
+
.tcp_tcp_socket_receive_buffer_size(socket)
|
|
2618
|
+
.into_answer()?
|
|
2619
|
+
.expect("the size reads"),
|
|
2620
|
+
))
|
|
2621
|
+
};
|
|
2622
|
+
let before = read(&mut guest)?;
|
|
2623
|
+
guest
|
|
2624
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
2625
|
+
.into_answer()?
|
|
2626
|
+
.expect("the endpoint names the listener");
|
|
2627
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
2628
|
+
guest.poll_pollable_block(connecting)?;
|
|
2629
|
+
guest
|
|
2630
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
2631
|
+
.into_answer()?
|
|
2632
|
+
.expect("the listener accepts");
|
|
2633
|
+
sizes.push((before, read(&mut guest)?));
|
|
2634
|
+
}
|
|
2635
|
+
Ok::<_, wasmtime::Error>(sizes)
|
|
2636
|
+
})
|
|
2637
|
+
.unwrap();
|
|
2638
|
+
assert_eq!(
|
|
2639
|
+
sizes,
|
|
2640
|
+
[
|
|
2641
|
+
((8_192, 32_768), (32_768, 32_768)),
|
|
2642
|
+
((2_304, 32_768), (2_304, 32_768)),
|
|
2643
|
+
],
|
|
2644
|
+
"send-buffer-size of a new TCP socket must read Linux's tcp_wmem default of 16384, \
|
|
2645
|
+
halved as wasmtime-wasi halves what Linux doubles, until it connects, then the \
|
|
2646
|
+
socket's own 65536 halved; one set to 1000 must read Linux's least of 4608 halved \
|
|
2647
|
+
before and after; receive-buffer-size reads 65536 halved throughout"
|
|
2648
|
+
);
|
|
2649
|
+
}
|
|
2650
|
+
|
|
2651
|
+
// @behavior NW-165
|
|
2652
|
+
#[test]
|
|
2653
|
+
fn a_read_of_nothing_after_a_failed_read_answers_closed() {
|
|
2654
|
+
let (mut guest, listener) = guest_and_listener();
|
|
2655
|
+
let port = listener.local_addr().unwrap().port();
|
|
2656
|
+
let answers = run_task(Some(Instant::now() + Duration::from_secs(10)), || {
|
|
2657
|
+
let network = guest.instance_network_instance_network()?;
|
|
2658
|
+
let (_, input, output) = connect_loopback(&mut guest, network, port)?;
|
|
2659
|
+
let (peer, _) = listener.accept().unwrap();
|
|
2660
|
+
// The peer closes with these bytes unread, so it resets.
|
|
2661
|
+
guest
|
|
2662
|
+
.streams_output_stream_blocking_write_and_flush(output, b"unread".to_vec())
|
|
2663
|
+
.into_answer()?
|
|
2664
|
+
.expect("the bytes leave");
|
|
2665
|
+
std::thread::sleep(Duration::from_millis(20));
|
|
2666
|
+
drop(peer);
|
|
2667
|
+
let failed = loop {
|
|
2668
|
+
let readable = guest.streams_input_stream_subscribe(input)?;
|
|
2669
|
+
guest.poll_pollable_block(readable)?;
|
|
2670
|
+
guest.poll_pollable_drop(readable)?;
|
|
2671
|
+
match guest.streams_input_stream_read(input, 8).into_answer()? {
|
|
2672
|
+
Ok(bytes) if bytes.is_empty() => continue,
|
|
2673
|
+
answer => break answer.is_err(),
|
|
2674
|
+
}
|
|
2675
|
+
};
|
|
2676
|
+
let nothing = matches!(
|
|
2677
|
+
guest.streams_input_stream_read(input, 0).into_answer()?,
|
|
2678
|
+
Err(crate::preview2::error::StreamError::Closed)
|
|
2679
|
+
);
|
|
2680
|
+
Ok::<_, wasmtime::Error>((failed, nothing))
|
|
2681
|
+
})
|
|
2682
|
+
.expect("the calls answer");
|
|
2683
|
+
assert_eq!(
|
|
2684
|
+
answers,
|
|
2685
|
+
(true, true),
|
|
2686
|
+
"input-stream.read of nothing after a read failed on a reset must answer closed, as \
|
|
2687
|
+
wasmtime's stream closes on a failed read"
|
|
2688
|
+
);
|
|
2689
|
+
}
|
|
2690
|
+
|
|
2691
|
+
// @behavior NW-155
|
|
2692
|
+
#[test]
|
|
2693
|
+
fn a_flushing_streams_pollable_waits_until_what_it_flushes_has_left() {
|
|
2694
|
+
let (mut guest, listener) = guest_and_listener();
|
|
2695
|
+
let port = listener.local_addr().unwrap().port();
|
|
2696
|
+
let started = Instant::now();
|
|
2697
|
+
let answers = run_task(Some(started + Duration::from_secs(30)), || {
|
|
2698
|
+
let network = guest.instance_network_instance_network()?;
|
|
2699
|
+
let socket = guest
|
|
2700
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2701
|
+
.into_answer()?
|
|
2702
|
+
.expect("a network makes a socket");
|
|
2703
|
+
guest
|
|
2704
|
+
.tcp_tcp_socket_set_send_buffer_size(socket, 4096)
|
|
2705
|
+
.into_answer()?
|
|
2706
|
+
.expect("a socket takes a send buffer");
|
|
2707
|
+
guest
|
|
2708
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
2709
|
+
.into_answer()?
|
|
2710
|
+
.expect("the endpoint names the listener");
|
|
2711
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
2712
|
+
guest.poll_pollable_block(connecting)?;
|
|
2713
|
+
let (_, output) = guest
|
|
2714
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
2715
|
+
.into_answer()?
|
|
2716
|
+
.expect("the listener accepts");
|
|
2717
|
+
let (mut peer, _) = listener.accept().unwrap();
|
|
2718
|
+
// Fill the host's buffers and the socket's own, the peer reading
|
|
2719
|
+
// nothing, so what a flush holds cannot leave.
|
|
2720
|
+
let mut quiet = 0;
|
|
2721
|
+
while quiet < 20 {
|
|
2722
|
+
match guest
|
|
2723
|
+
.streams_output_stream_check_write(output)
|
|
2724
|
+
.into_answer()?
|
|
2725
|
+
{
|
|
2726
|
+
Ok(0) => {
|
|
2727
|
+
quiet += 1;
|
|
2728
|
+
std::thread::sleep(Duration::from_millis(5));
|
|
2729
|
+
}
|
|
2730
|
+
Ok(room) => {
|
|
2731
|
+
quiet = 0;
|
|
2732
|
+
let chunk = vec![b'x'; room.min(4096) as usize];
|
|
2733
|
+
let _ = guest
|
|
2734
|
+
.streams_output_stream_write(output, chunk)
|
|
2735
|
+
.into_answer()?;
|
|
2736
|
+
}
|
|
2737
|
+
Err(_) => break,
|
|
2738
|
+
}
|
|
2739
|
+
}
|
|
2740
|
+
guest
|
|
2741
|
+
.streams_output_stream_flush(output)
|
|
2742
|
+
.into_answer()?
|
|
2743
|
+
.expect("a connected stream flushes");
|
|
2744
|
+
let writable = guest.streams_output_stream_subscribe(output)?;
|
|
2745
|
+
let now = guest.monotonic_clock_subscribe_duration(0)?;
|
|
2746
|
+
let while_held = guest.poll_poll(vec![writable, now])?;
|
|
2747
|
+
let reader = std::thread::spawn(move || {
|
|
2748
|
+
let mut sink = [0u8; 65536];
|
|
2749
|
+
while std::io::Read::read(&mut peer, &mut sink).is_ok_and(|n| n > 0) {}
|
|
2750
|
+
});
|
|
2751
|
+
guest.poll_pollable_block(writable)?;
|
|
2752
|
+
let after = guest
|
|
2753
|
+
.streams_output_stream_check_write(output)
|
|
2754
|
+
.into_answer()?
|
|
2755
|
+
.ok();
|
|
2756
|
+
Ok::<_, wasmtime::Error>((while_held, after, reader))
|
|
2757
|
+
})
|
|
2758
|
+
.expect("the stream fills and drains");
|
|
2759
|
+
let (while_held, after, _reader) = answers;
|
|
2760
|
+
assert!(
|
|
2761
|
+
while_held == [1] && after.is_some_and(|room| room > 0),
|
|
2762
|
+
"output-stream.subscribe after a flush the peer has not taken must not be ready, \
|
|
2763
|
+
only the zero-length clock beside it, and once the peer reads, it must be ready \
|
|
2764
|
+
with check-write offering bytes; polled {while_held:?}, then offered {after:?}"
|
|
2765
|
+
);
|
|
2766
|
+
}
|
|
2767
|
+
|
|
2768
|
+
// @behavior NW-089
|
|
2769
|
+
#[test]
|
|
2770
|
+
fn an_address_wasi_calls_invalid_answers_invalid_argument() {
|
|
2771
|
+
let (mut guest, _listener) = guest_and_listener();
|
|
2772
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
2773
|
+
let connect = |guest: &mut Invocation, to| {
|
|
2774
|
+
let socket = guest
|
|
2775
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2776
|
+
.into_answer()
|
|
2777
|
+
.unwrap()
|
|
2778
|
+
.expect("a network makes a socket");
|
|
2779
|
+
guest
|
|
2780
|
+
.tcp_tcp_socket_start_connect(socket, network, to)
|
|
2781
|
+
.into_answer()
|
|
2782
|
+
.unwrap()
|
|
2783
|
+
};
|
|
2784
|
+
let connects = [
|
|
2785
|
+
connect(&mut guest, ipv4((0, 0, 0, 0), 80)),
|
|
2786
|
+
connect(&mut guest, ipv4((127, 0, 0, 1), 0)),
|
|
2787
|
+
connect(&mut guest, ipv4((255, 255, 255, 255), 80)),
|
|
2788
|
+
connect(&mut guest, ipv4((224, 0, 0, 1), 80)),
|
|
2789
|
+
];
|
|
2790
|
+
let udp = guest
|
|
2791
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2792
|
+
.into_answer()
|
|
2793
|
+
.unwrap()
|
|
2794
|
+
.expect("a network makes a socket");
|
|
2795
|
+
let tcp_bind = {
|
|
2796
|
+
let socket = guest
|
|
2797
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2798
|
+
.into_answer()
|
|
2799
|
+
.unwrap()
|
|
2800
|
+
.expect("a network makes a socket");
|
|
2801
|
+
guest
|
|
2802
|
+
.tcp_tcp_socket_start_bind(socket, network, ipv4((224, 0, 0, 1), 0))
|
|
2803
|
+
.into_answer()
|
|
2804
|
+
.unwrap()
|
|
2805
|
+
};
|
|
2806
|
+
let udp_bind = guest
|
|
2807
|
+
.udp_udp_socket_start_bind(udp, network, ipv4((224, 0, 0, 1), 0))
|
|
2808
|
+
.into_answer()
|
|
2809
|
+
.unwrap();
|
|
2810
|
+
let bound = guest
|
|
2811
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2812
|
+
.into_answer()
|
|
2813
|
+
.unwrap()
|
|
2814
|
+
.expect("a network makes a socket");
|
|
2815
|
+
guest
|
|
2816
|
+
.udp_udp_socket_start_bind(bound, network, ipv4((0, 0, 0, 0), 0))
|
|
2817
|
+
.into_answer()
|
|
2818
|
+
.unwrap()
|
|
2819
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2820
|
+
guest
|
|
2821
|
+
.udp_udp_socket_finish_bind(bound)
|
|
2822
|
+
.into_answer()
|
|
2823
|
+
.unwrap()
|
|
2824
|
+
.expect("the bind settles");
|
|
2825
|
+
let mut stream = |to| {
|
|
2826
|
+
guest
|
|
2827
|
+
.udp_udp_socket_stream(bound, Some(to))
|
|
2828
|
+
.into_answer()
|
|
2829
|
+
.unwrap()
|
|
2830
|
+
.map(drop)
|
|
2831
|
+
};
|
|
2832
|
+
let streams = [
|
|
2833
|
+
stream(ipv4((0, 0, 0, 0), 80)),
|
|
2834
|
+
stream(ipv4((127, 0, 0, 1), 0)),
|
|
2835
|
+
stream(ipv4((255, 255, 255, 255), 80)),
|
|
2836
|
+
stream(ipv4((224, 0, 0, 1), 80)),
|
|
2837
|
+
];
|
|
2838
|
+
assert_eq!(
|
|
2839
|
+
(connects, tcp_bind, udp_bind, streams),
|
|
2840
|
+
(
|
|
2841
|
+
[Err(ErrorCode::InvalidArgument); 4],
|
|
2842
|
+
Err(ErrorCode::InvalidArgument),
|
|
2843
|
+
Err(ErrorCode::AccessDenied),
|
|
2844
|
+
[
|
|
2845
|
+
Err(ErrorCode::InvalidArgument),
|
|
2846
|
+
Err(ErrorCode::InvalidArgument),
|
|
2847
|
+
Err(ErrorCode::AccessDenied),
|
|
2848
|
+
Err(ErrorCode::AccessDenied)
|
|
2849
|
+
]
|
|
2850
|
+
),
|
|
2851
|
+
"start-connect to 0.0.0.0, port 0, a broadcast, or a multicast address, and a TCP \
|
|
2852
|
+
start-bind to a multicast address, must answer invalid-argument; a UDP socket \
|
|
2853
|
+
checks only the unspecified address and port 0 that way, as wasmtime's, so its \
|
|
2854
|
+
multicast bind and broadcast or multicast stream answer access-denied"
|
|
2855
|
+
);
|
|
2856
|
+
}
|
|
2857
|
+
|
|
2858
|
+
// @behavior NW-200
|
|
2859
|
+
#[test]
|
|
2860
|
+
fn an_address_of_another_family_answers_invalid_argument() {
|
|
2861
|
+
let (mut guest, _listener) = guest_and_listener();
|
|
2862
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
2863
|
+
let loopback = || {
|
|
2864
|
+
IpSocketAddress::Ipv6(Ipv6SocketAddress {
|
|
2865
|
+
port: 80,
|
|
2866
|
+
flow_info: 0,
|
|
2867
|
+
address: (0, 0, 0, 0, 0, 0, 0, 1),
|
|
2868
|
+
scope_id: 0,
|
|
2869
|
+
})
|
|
2870
|
+
};
|
|
2871
|
+
let mut tcp = || {
|
|
2872
|
+
guest
|
|
2873
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2874
|
+
.into_answer()
|
|
2875
|
+
.unwrap()
|
|
2876
|
+
.expect("a network makes a socket")
|
|
2877
|
+
};
|
|
2878
|
+
let (bound, connected) = (tcp(), tcp());
|
|
2879
|
+
let tcp_bind = guest
|
|
2880
|
+
.tcp_tcp_socket_start_bind(bound, network, loopback())
|
|
2881
|
+
.into_answer()
|
|
2882
|
+
.unwrap();
|
|
2883
|
+
let tcp_connect = guest
|
|
2884
|
+
.tcp_tcp_socket_start_connect(connected, network, loopback())
|
|
2885
|
+
.into_answer()
|
|
2886
|
+
.unwrap();
|
|
2887
|
+
let mut udp = || {
|
|
2888
|
+
guest
|
|
2889
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2890
|
+
.into_answer()
|
|
2891
|
+
.unwrap()
|
|
2892
|
+
.expect("a network makes a socket")
|
|
2893
|
+
};
|
|
2894
|
+
let (unbound, streaming) = (udp(), udp());
|
|
2895
|
+
let udp_bind = guest
|
|
2896
|
+
.udp_udp_socket_start_bind(unbound, network, loopback())
|
|
2897
|
+
.into_answer()
|
|
2898
|
+
.unwrap();
|
|
2899
|
+
guest
|
|
2900
|
+
.udp_udp_socket_start_bind(streaming, network, ipv4((0, 0, 0, 0), 0))
|
|
2901
|
+
.into_answer()
|
|
2902
|
+
.unwrap()
|
|
2903
|
+
.expect("an ephemeral bind is the implicit one");
|
|
2904
|
+
guest
|
|
2905
|
+
.udp_udp_socket_finish_bind(streaming)
|
|
2906
|
+
.into_answer()
|
|
2907
|
+
.unwrap()
|
|
2908
|
+
.expect("the bind settles");
|
|
2909
|
+
let udp_stream = guest
|
|
2910
|
+
.udp_udp_socket_stream(streaming, Some(loopback()))
|
|
2911
|
+
.into_answer()
|
|
2912
|
+
.unwrap()
|
|
2913
|
+
.map(drop);
|
|
2914
|
+
assert_eq!(
|
|
2915
|
+
[tcp_bind, tcp_connect, udp_bind, udp_stream],
|
|
2916
|
+
[Err(ErrorCode::InvalidArgument); 4],
|
|
2917
|
+
"an IPv4 socket's start-bind, start-connect, or stream to an IPv6 address must answer \
|
|
2918
|
+
invalid-argument, as WIT names an address of the wrong family"
|
|
2919
|
+
);
|
|
2920
|
+
}
|
|
2921
|
+
|
|
2922
|
+
// @behavior NW-090
|
|
2923
|
+
#[test]
|
|
2924
|
+
fn a_second_start_while_one_is_under_way_answers_concurrency_conflict() {
|
|
2925
|
+
let (mut guest, listener) = guest_and_listener();
|
|
2926
|
+
let port = listener.local_addr().unwrap().port();
|
|
2927
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
2928
|
+
let socket = guest
|
|
2929
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2930
|
+
.into_answer()
|
|
2931
|
+
.unwrap()
|
|
2932
|
+
.expect("a network makes a socket");
|
|
2933
|
+
let to = ipv4((127, 0, 0, 1), port);
|
|
2934
|
+
let first = guest
|
|
2935
|
+
.tcp_tcp_socket_start_connect(socket, network, to.clone())
|
|
2936
|
+
.into_answer();
|
|
2937
|
+
let again = guest
|
|
2938
|
+
.tcp_tcp_socket_start_connect(socket, network, to)
|
|
2939
|
+
.into_answer();
|
|
2940
|
+
let bound_while_connecting = guest
|
|
2941
|
+
.tcp_tcp_socket_start_bind(socket, network, ipv4((0, 0, 0, 0), 0))
|
|
2942
|
+
.into_answer();
|
|
2943
|
+
let udp = guest
|
|
2944
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
2945
|
+
.into_answer()
|
|
2946
|
+
.unwrap()
|
|
2947
|
+
.expect("a network makes a socket");
|
|
2948
|
+
let bound = guest
|
|
2949
|
+
.udp_udp_socket_start_bind(udp, network, ipv4((0, 0, 0, 0), 0))
|
|
2950
|
+
.into_answer();
|
|
2951
|
+
let rebound = guest
|
|
2952
|
+
.udp_udp_socket_start_bind(udp, network, ipv4((0, 0, 0, 0), 0))
|
|
2953
|
+
.into_answer();
|
|
2954
|
+
assert_eq!(
|
|
2955
|
+
(
|
|
2956
|
+
first.unwrap(),
|
|
2957
|
+
again.unwrap(),
|
|
2958
|
+
bound_while_connecting.unwrap(),
|
|
2959
|
+
bound.unwrap(),
|
|
2960
|
+
rebound.unwrap()
|
|
2961
|
+
),
|
|
2962
|
+
(
|
|
2963
|
+
Ok(()),
|
|
2964
|
+
Err(ErrorCode::ConcurrencyConflict),
|
|
2965
|
+
Err(ErrorCode::ConcurrencyConflict),
|
|
2966
|
+
Ok(()),
|
|
2967
|
+
Err(ErrorCode::ConcurrencyConflict)
|
|
2968
|
+
),
|
|
2969
|
+
"start-connect again, or a TCP start-bind, while a connect is under way, and \
|
|
2970
|
+
start-bind again before its finish, must answer concurrency-conflict"
|
|
2971
|
+
);
|
|
2972
|
+
}
|
|
2973
|
+
|
|
2974
|
+
// @behavior NW-091
|
|
2975
|
+
#[test]
|
|
2976
|
+
fn a_tcp_sockets_pollable_waits_only_on_its_connect() {
|
|
2977
|
+
let (mut guest, listener) = guest_and_listener();
|
|
2978
|
+
let port = listener.local_addr().unwrap().port();
|
|
2979
|
+
let started = Instant::now();
|
|
2980
|
+
let answered = run_task(Some(started + Duration::from_secs(10)), || {
|
|
2981
|
+
let network = guest.instance_network_instance_network()?;
|
|
2982
|
+
let fresh = guest
|
|
2983
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2984
|
+
.into_answer()?
|
|
2985
|
+
.expect("a network makes a socket");
|
|
2986
|
+
let idle = guest.tcp_tcp_socket_subscribe(fresh)?;
|
|
2987
|
+
guest.poll_pollable_block(idle)?;
|
|
2988
|
+
let socket = guest
|
|
2989
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
2990
|
+
.into_answer()?
|
|
2991
|
+
.expect("a network makes a socket");
|
|
2992
|
+
guest
|
|
2993
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
2994
|
+
.into_answer()?
|
|
2995
|
+
.expect("the endpoint names the listener");
|
|
2996
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
2997
|
+
guest.poll_pollable_block(connecting)?;
|
|
2998
|
+
let (_, output) = guest
|
|
2999
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3000
|
+
.into_answer()?
|
|
3001
|
+
.expect("the listener accepts");
|
|
3002
|
+
// The listener never reads, so once the host's buffers fill too the
|
|
3003
|
+
// send buffer stays full and a wait for room would hold; the
|
|
3004
|
+
// pollable answers anyway once connected.
|
|
3005
|
+
let mut full_for = 0;
|
|
3006
|
+
while full_for < 5 {
|
|
3007
|
+
match guest
|
|
3008
|
+
.streams_output_stream_check_write(output)
|
|
3009
|
+
.into_answer()?
|
|
3010
|
+
{
|
|
3011
|
+
Ok(0) => {
|
|
3012
|
+
full_for += 1;
|
|
3013
|
+
std::thread::sleep(Duration::from_millis(50));
|
|
3014
|
+
}
|
|
3015
|
+
Ok(n) => {
|
|
3016
|
+
full_for = 0;
|
|
3017
|
+
guest
|
|
3018
|
+
.streams_output_stream_write(output, vec![b'x'; n as usize])
|
|
3019
|
+
.into_answer()?
|
|
3020
|
+
.expect("the stream takes what it permitted");
|
|
3021
|
+
}
|
|
3022
|
+
Err(_) => return Err(wasmtime::Error::msg("the stream failed")),
|
|
3023
|
+
}
|
|
3024
|
+
}
|
|
3025
|
+
let connected = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3026
|
+
guest.poll_pollable_block(connected)?;
|
|
3027
|
+
guest.poll_pollable_block(connecting)?;
|
|
3028
|
+
Ok::<_, wasmtime::Error>(())
|
|
3029
|
+
});
|
|
3030
|
+
assert!(
|
|
3031
|
+
answered.is_ok() && started.elapsed() < Duration::from_secs(5),
|
|
3032
|
+
"pollable.block on a fresh socket's subscribe, on a connected socket's, and again on \
|
|
3033
|
+
the one taken while it connected, must answer at once, not {answered:?} after {:?}",
|
|
3034
|
+
started.elapsed()
|
|
3035
|
+
);
|
|
3036
|
+
}
|
|
3037
|
+
|
|
3038
|
+
// @behavior NW-179
|
|
3039
|
+
#[test]
|
|
3040
|
+
fn a_keepalive_time_rounds_a_part_of_a_second_up() {
|
|
3041
|
+
let (mut guest, _listener) = guest_and_listener();
|
|
3042
|
+
let socket = guest
|
|
3043
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3044
|
+
.into_answer()
|
|
3045
|
+
.unwrap()
|
|
3046
|
+
.expect("a network makes a socket");
|
|
3047
|
+
let mut set_and_read = |idle: u64, interval: u64| {
|
|
3048
|
+
guest
|
|
3049
|
+
.tcp_tcp_socket_set_keep_alive_idle_time(socket, idle)
|
|
3050
|
+
.into_answer()
|
|
3051
|
+
.unwrap()
|
|
3052
|
+
.expect("a fresh socket takes the idle time");
|
|
3053
|
+
guest
|
|
3054
|
+
.tcp_tcp_socket_set_keep_alive_interval(socket, interval)
|
|
3055
|
+
.into_answer()
|
|
3056
|
+
.unwrap()
|
|
3057
|
+
.expect("a fresh socket takes the interval");
|
|
3058
|
+
(
|
|
3059
|
+
guest
|
|
3060
|
+
.tcp_tcp_socket_keep_alive_idle_time(socket)
|
|
3061
|
+
.into_answer()
|
|
3062
|
+
.unwrap(),
|
|
3063
|
+
guest
|
|
3064
|
+
.tcp_tcp_socket_keep_alive_interval(socket)
|
|
3065
|
+
.into_answer()
|
|
3066
|
+
.unwrap(),
|
|
3067
|
+
)
|
|
3068
|
+
};
|
|
3069
|
+
assert_eq!(
|
|
3070
|
+
[
|
|
3071
|
+
set_and_read(1_500_000_000, 500_000_000),
|
|
3072
|
+
set_and_read(2_000_000_000, 1)
|
|
3073
|
+
],
|
|
3074
|
+
[
|
|
3075
|
+
(Ok(2_000_000_000), Ok(1_000_000_000)),
|
|
3076
|
+
(Ok(2_000_000_000), Ok(1_000_000_000))
|
|
3077
|
+
],
|
|
3078
|
+
"tcp-socket keep-alive times of 1.5 s and 0.5 s must read back 2 s and 1 s, and whole \
|
|
3079
|
+
seconds unchanged, as wasmtime's pass through rustix, which rounds a part of a \
|
|
3080
|
+
second up"
|
|
3081
|
+
);
|
|
3082
|
+
}
|
|
3083
|
+
|
|
3084
|
+
// @behavior NW-092
|
|
3085
|
+
#[test]
|
|
3086
|
+
fn a_write_past_the_last_check_write_permit_traps() {
|
|
3087
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3088
|
+
let port = listener.local_addr().unwrap().port();
|
|
3089
|
+
let started = Instant::now();
|
|
3090
|
+
let (permitted, within, past) = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3091
|
+
let network = guest.instance_network_instance_network()?;
|
|
3092
|
+
let (_, _, output) = connect_loopback(&mut guest, network, port)?;
|
|
3093
|
+
let permitted = guest
|
|
3094
|
+
.streams_output_stream_check_write(output)
|
|
3095
|
+
.into_answer()?
|
|
3096
|
+
.expect("a connected stream permits");
|
|
3097
|
+
let within = guest
|
|
3098
|
+
.streams_output_stream_write(output, vec![b'x'])
|
|
3099
|
+
.into_answer();
|
|
3100
|
+
let past = guest
|
|
3101
|
+
.streams_output_stream_write(output, vec![b'x'])
|
|
3102
|
+
.into_answer();
|
|
3103
|
+
Ok::<_, wasmtime::Error>((permitted, within.is_ok(), past.is_err()))
|
|
3104
|
+
})
|
|
3105
|
+
.expect("the connect answers");
|
|
3106
|
+
assert!(
|
|
3107
|
+
permitted > 1 && within && past,
|
|
3108
|
+
"output-stream.write of one byte of what check-write permitted must succeed, and \
|
|
3109
|
+
another byte without another check-write must trap, as a permit is for the next \
|
|
3110
|
+
write only"
|
|
3111
|
+
);
|
|
3112
|
+
}
|
|
3113
|
+
|
|
3114
|
+
// @behavior NW-159
|
|
3115
|
+
#[test]
|
|
3116
|
+
fn an_empty_write_leaves_the_check_write_permit() {
|
|
3117
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3118
|
+
let port = listener.local_addr().unwrap().port();
|
|
3119
|
+
let started = Instant::now();
|
|
3120
|
+
let (empty, byte) = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3121
|
+
let network = guest.instance_network_instance_network()?;
|
|
3122
|
+
let (_, _, output) = connect_loopback(&mut guest, network, port)?;
|
|
3123
|
+
guest
|
|
3124
|
+
.streams_output_stream_check_write(output)
|
|
3125
|
+
.into_answer()?
|
|
3126
|
+
.expect("a connected stream permits");
|
|
3127
|
+
let empty = guest
|
|
3128
|
+
.streams_output_stream_write(output, Vec::new())
|
|
3129
|
+
.into_answer();
|
|
3130
|
+
let byte = guest
|
|
3131
|
+
.streams_output_stream_write(output, vec![b'x'])
|
|
3132
|
+
.into_answer();
|
|
3133
|
+
Ok::<_, wasmtime::Error>((empty.is_ok(), byte.is_ok()))
|
|
3134
|
+
})
|
|
3135
|
+
.expect("the connect answers");
|
|
3136
|
+
assert_eq!(
|
|
3137
|
+
(empty, byte),
|
|
3138
|
+
(true, true),
|
|
3139
|
+
"output-stream.write of no bytes must succeed and leave the check-write permit, so \
|
|
3140
|
+
one byte after it still writes, as wasmtime's write does"
|
|
3141
|
+
);
|
|
3142
|
+
}
|
|
3143
|
+
|
|
3144
|
+
// @behavior NW-171
|
|
3145
|
+
#[test]
|
|
3146
|
+
fn a_write_the_socket_no_longer_takes_whole_fails() {
|
|
3147
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3148
|
+
let port = listener.local_addr().unwrap().port();
|
|
3149
|
+
let started = Instant::now();
|
|
3150
|
+
let written = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3151
|
+
let network = guest.instance_network_instance_network()?;
|
|
3152
|
+
let (socket, _, output) = connect_loopback(&mut guest, network, port)?;
|
|
3153
|
+
let permit = guest
|
|
3154
|
+
.streams_output_stream_check_write(output)
|
|
3155
|
+
.into_answer()?
|
|
3156
|
+
.expect("a connected stream permits");
|
|
3157
|
+
guest
|
|
3158
|
+
.tcp_tcp_socket_set_send_buffer_size(socket, 1)
|
|
3159
|
+
.into_answer()?
|
|
3160
|
+
.expect("a connected socket takes a send buffer size");
|
|
3161
|
+
let written = guest
|
|
3162
|
+
.streams_output_stream_write(output, vec![0; permit as usize])
|
|
3163
|
+
.into_answer()?;
|
|
3164
|
+
let after = guest
|
|
3165
|
+
.streams_output_stream_check_write(output)
|
|
3166
|
+
.into_answer()?;
|
|
3167
|
+
Ok::<_, wasmtime::Error>((written.is_ok(), matches!(after, Err(StreamError::Closed))))
|
|
3168
|
+
})
|
|
3169
|
+
.expect("the calls answer");
|
|
3170
|
+
let (mut peer, _) = listener.accept().expect("the listener accepts");
|
|
3171
|
+
peer.set_read_timeout(Some(Duration::from_millis(200)))
|
|
3172
|
+
.unwrap();
|
|
3173
|
+
let heard = std::io::Read::read(&mut peer, &mut [0; 16]).ok();
|
|
3174
|
+
assert_eq!(
|
|
3175
|
+
(written, heard),
|
|
3176
|
+
((false, true), None),
|
|
3177
|
+
"output-stream.write of the whole check-write permit after the guest shrank the \
|
|
3178
|
+
socket's send buffer must fail before any byte leaves, rather than send the peer \
|
|
3179
|
+
part of it, and the next check-write must answer closed, as io.wit closes a stream \
|
|
3180
|
+
past last-operation-failed"
|
|
3181
|
+
);
|
|
3182
|
+
}
|
|
3183
|
+
|
|
3184
|
+
// @behavior NW-182
|
|
3185
|
+
#[test]
|
|
3186
|
+
fn a_blocking_flush_after_the_send_side_shut_answers_closed() {
|
|
3187
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3188
|
+
let port = listener.local_addr().unwrap().port();
|
|
3189
|
+
let started = Instant::now();
|
|
3190
|
+
let answers = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3191
|
+
let network = guest.instance_network_instance_network()?;
|
|
3192
|
+
let (socket, _, output) = connect_loopback(&mut guest, network, port)?;
|
|
3193
|
+
guest
|
|
3194
|
+
.tcp_tcp_socket_shutdown(socket, ShutdownType::Send)
|
|
3195
|
+
.into_answer()?
|
|
3196
|
+
.expect("a connected socket shuts its send side");
|
|
3197
|
+
let nothing = guest
|
|
3198
|
+
.streams_output_stream_blocking_write_and_flush(output, Vec::new())
|
|
3199
|
+
.into_answer()?;
|
|
3200
|
+
Ok::<_, wasmtime::Error>(matches!(nothing, Err(StreamError::Closed)))
|
|
3201
|
+
});
|
|
3202
|
+
assert!(
|
|
3203
|
+
matches!(answers, Ok(true)),
|
|
3204
|
+
"output-stream.blocking-write-and-flush of no bytes after tcp-socket.shutdown of the \
|
|
3205
|
+
send side must answer closed, as wasmtime's first asks the stream for room, not \
|
|
3206
|
+
{answers:?}"
|
|
3207
|
+
);
|
|
3208
|
+
}
|
|
3209
|
+
|
|
3210
|
+
// @behavior NW-229
|
|
3211
|
+
#[test]
|
|
3212
|
+
fn a_blocking_flush_after_the_send_side_shut_answers_closed_though_bytes_wait() {
|
|
3213
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3214
|
+
let port = listener.local_addr().unwrap().port();
|
|
3215
|
+
let started = Instant::now();
|
|
3216
|
+
let answers = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3217
|
+
let network = guest.instance_network_instance_network()?;
|
|
3218
|
+
let socket = guest
|
|
3219
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3220
|
+
.into_answer()?
|
|
3221
|
+
.expect("a network makes a socket");
|
|
3222
|
+
guest
|
|
3223
|
+
.tcp_tcp_socket_set_send_buffer_size(socket, 4096)
|
|
3224
|
+
.into_answer()?
|
|
3225
|
+
.expect("a socket takes a send buffer");
|
|
3226
|
+
guest
|
|
3227
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
3228
|
+
.into_answer()?
|
|
3229
|
+
.expect("the endpoint names the listener");
|
|
3230
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3231
|
+
guest.poll_pollable_block(connecting)?;
|
|
3232
|
+
let (_, output) = guest
|
|
3233
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3234
|
+
.into_answer()?
|
|
3235
|
+
.expect("the listener accepts");
|
|
3236
|
+
let (_peer, _) = listener.accept().unwrap();
|
|
3237
|
+
// Fill the host's buffers and the socket's own, the peer reading
|
|
3238
|
+
// nothing, so what is queued cannot leave.
|
|
3239
|
+
let mut quiet = 0;
|
|
3240
|
+
while quiet < 20 {
|
|
3241
|
+
match guest
|
|
3242
|
+
.streams_output_stream_check_write(output)
|
|
3243
|
+
.into_answer()?
|
|
3244
|
+
{
|
|
3245
|
+
Ok(0) => {
|
|
3246
|
+
quiet += 1;
|
|
3247
|
+
std::thread::sleep(Duration::from_millis(5));
|
|
3248
|
+
}
|
|
3249
|
+
Ok(room) => {
|
|
3250
|
+
quiet = 0;
|
|
3251
|
+
let chunk = vec![b'x'; room.min(4096) as usize];
|
|
3252
|
+
let _ = guest
|
|
3253
|
+
.streams_output_stream_write(output, chunk)
|
|
3254
|
+
.into_answer()?;
|
|
3255
|
+
}
|
|
3256
|
+
Err(_) => break,
|
|
3257
|
+
}
|
|
3258
|
+
}
|
|
3259
|
+
guest
|
|
3260
|
+
.tcp_tcp_socket_shutdown(socket, ShutdownType::Send)
|
|
3261
|
+
.into_answer()?
|
|
3262
|
+
.expect("a connected socket shuts its send side");
|
|
3263
|
+
let asked = Instant::now();
|
|
3264
|
+
let nothing = guest
|
|
3265
|
+
.streams_output_stream_blocking_write_and_flush(output, Vec::new())
|
|
3266
|
+
.into_answer()?;
|
|
3267
|
+
Ok::<_, wasmtime::Error>((
|
|
3268
|
+
matches!(nothing, Err(StreamError::Closed)),
|
|
3269
|
+
asked.elapsed() < Duration::from_secs(2),
|
|
3270
|
+
))
|
|
3271
|
+
});
|
|
3272
|
+
assert!(
|
|
3273
|
+
matches!(answers, Ok((true, true))),
|
|
3274
|
+
"output-stream.blocking-write-and-flush of no bytes after tcp-socket.shutdown of the \
|
|
3275
|
+
send side, with bytes queued that the peer never reads, must answer closed at once, \
|
|
3276
|
+
as wasmtime asks the stream for room before it waits, not {answers:?}"
|
|
3277
|
+
);
|
|
3278
|
+
}
|
|
3279
|
+
|
|
3280
|
+
// @behavior NW-186
|
|
3281
|
+
#[test]
|
|
3282
|
+
fn a_shutdown_of_the_receive_side_closes_the_input_stream() {
|
|
3283
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3284
|
+
let port = listener.local_addr().unwrap().port();
|
|
3285
|
+
let started = Instant::now();
|
|
3286
|
+
let answers = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3287
|
+
let network = guest.instance_network_instance_network()?;
|
|
3288
|
+
let socket = guest
|
|
3289
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3290
|
+
.into_answer()?
|
|
3291
|
+
.expect("a network makes a socket");
|
|
3292
|
+
guest
|
|
3293
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
3294
|
+
.into_answer()?
|
|
3295
|
+
.expect("the endpoint names the listener");
|
|
3296
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3297
|
+
guest.poll_pollable_block(connecting)?;
|
|
3298
|
+
let (input, _) = guest
|
|
3299
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3300
|
+
.into_answer()?
|
|
3301
|
+
.expect("the listener accepts");
|
|
3302
|
+
let (mut peer, _) = listener.accept().expect("the listener accepts");
|
|
3303
|
+
std::io::Write::write_all(&mut peer, b"queued").expect("the peer sends");
|
|
3304
|
+
let readable = guest.streams_input_stream_subscribe(input)?;
|
|
3305
|
+
guest.poll_pollable_block(readable)?;
|
|
3306
|
+
guest
|
|
3307
|
+
.tcp_tcp_socket_shutdown(socket, ShutdownType::Receive)
|
|
3308
|
+
.into_answer()?
|
|
3309
|
+
.expect("a connected socket shuts its receive side");
|
|
3310
|
+
let read = guest.streams_input_stream_read(input, 16).into_answer()?;
|
|
3311
|
+
Ok::<_, wasmtime::Error>(matches!(read, Err(StreamError::Closed)))
|
|
3312
|
+
});
|
|
3313
|
+
assert!(
|
|
3314
|
+
matches!(answers, Ok(true)),
|
|
3315
|
+
"input-stream.read after tcp-socket.shutdown of the receive side must answer closed, \
|
|
3316
|
+
though bytes were queued, as tcp.wit closes the input stream and discards its queue, \
|
|
3317
|
+
not {answers:?}"
|
|
3318
|
+
);
|
|
3319
|
+
}
|
|
3320
|
+
|
|
3321
|
+
// @behavior NW-171
|
|
3322
|
+
#[test]
|
|
3323
|
+
fn a_closed_output_streams_pollable_is_ready_at_once() {
|
|
3324
|
+
let mut guest = network_guest(network::Endpoint::new("127.0.0.1", 80).unwrap());
|
|
3325
|
+
// A refused lookup's file never polls writable, so only the stream's
|
|
3326
|
+
// own closed state can make its pollable ready.
|
|
3327
|
+
let lookup = resolve(guest.network(), "unnamed.test").expect("the lookup answers");
|
|
3328
|
+
let file = Arc::new(Mutex::new(lookup.alloc_file(guest.wasi().cred())));
|
|
3329
|
+
let output: OutputStream = guest
|
|
3330
|
+
.table_mut()
|
|
3331
|
+
.push(io::OutputStream::new(io::Stream::File(file)))
|
|
3332
|
+
.unwrap();
|
|
3333
|
+
let pollable = guest.streams_output_stream_subscribe(output).unwrap();
|
|
3334
|
+
let ready =
|
|
3335
|
+
|guest: &mut Invocation| guest.table_mut().get(pollable).unwrap().is_ready(None);
|
|
3336
|
+
let open = ready(&mut guest);
|
|
3337
|
+
guest
|
|
3338
|
+
.table_mut()
|
|
3339
|
+
.get(output)
|
|
3340
|
+
.unwrap()
|
|
3341
|
+
.closed
|
|
3342
|
+
.store(true, Ordering::Release);
|
|
3343
|
+
assert_eq!(
|
|
3344
|
+
(open, ready(&mut guest)),
|
|
3345
|
+
(false, true),
|
|
3346
|
+
"output-stream.subscribe of a stream that cannot take a write must not be ready, and \
|
|
3347
|
+
once the stream is closed it must be ready at once, as io.wit has a closed stream's \
|
|
3348
|
+
pollable"
|
|
3349
|
+
);
|
|
3350
|
+
}
|
|
3351
|
+
|
|
3352
|
+
// @behavior NW-160
|
|
3353
|
+
#[test]
|
|
3354
|
+
fn a_connecting_socket_answers_its_state_before_a_zero_buffer_size() {
|
|
3355
|
+
let (mut guest, listener) = guest_and_listener();
|
|
3356
|
+
let port = listener.local_addr().unwrap().port();
|
|
3357
|
+
let answers = (|| {
|
|
3358
|
+
let network = guest.instance_network_instance_network()?;
|
|
3359
|
+
let socket = guest
|
|
3360
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3361
|
+
.into_answer()?
|
|
3362
|
+
.expect("a network makes a socket");
|
|
3363
|
+
guest
|
|
3364
|
+
.tcp_tcp_socket_start_connect(socket, network, ipv4((127, 0, 0, 1), port))
|
|
3365
|
+
.into_answer()?
|
|
3366
|
+
.expect("the endpoint names the listener");
|
|
3367
|
+
Ok::<_, wasmtime::Error>((
|
|
3368
|
+
guest
|
|
3369
|
+
.tcp_tcp_socket_set_receive_buffer_size(socket, 0)
|
|
3370
|
+
.into_answer()?,
|
|
3371
|
+
guest
|
|
3372
|
+
.tcp_tcp_socket_set_send_buffer_size(socket, 0)
|
|
3373
|
+
.into_answer()?,
|
|
3374
|
+
))
|
|
3375
|
+
})()
|
|
3376
|
+
.expect("the connect starts");
|
|
3377
|
+
assert_eq!(
|
|
3378
|
+
answers,
|
|
3379
|
+
(Err(ErrorCode::InvalidState), Err(ErrorCode::InvalidState)),
|
|
3380
|
+
"tcp-socket set-receive-buffer-size and set-send-buffer-size of zero on a socket \
|
|
3381
|
+
still connecting must answer invalid-state, as wasmtime reads the socket before \
|
|
3382
|
+
the size"
|
|
3383
|
+
);
|
|
3384
|
+
}
|
|
3385
|
+
|
|
3386
|
+
// @behavior NW-084
|
|
3387
|
+
#[test]
|
|
3388
|
+
fn a_datagram_past_what_udp_carries_answers_datagram_too_large() {
|
|
3389
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
3390
|
+
let port = peer.local_addr().unwrap().port();
|
|
3391
|
+
let mut guest = network_guest(
|
|
3392
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
3393
|
+
.unwrap()
|
|
3394
|
+
.with_protocol(network::Protocol::Udp),
|
|
3395
|
+
);
|
|
3396
|
+
let started = Instant::now();
|
|
3397
|
+
let sent = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3398
|
+
let network = guest.instance_network_instance_network()?;
|
|
3399
|
+
let socket = guest
|
|
3400
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
3401
|
+
.into_answer()?
|
|
3402
|
+
.expect("a network makes a socket");
|
|
3403
|
+
let any = ipv4((0, 0, 0, 0), 0);
|
|
3404
|
+
guest
|
|
3405
|
+
.udp_udp_socket_start_bind(socket, network, any)
|
|
3406
|
+
.into_answer()?
|
|
3407
|
+
.expect("an ephemeral bind is the implicit one");
|
|
3408
|
+
guest
|
|
3409
|
+
.udp_udp_socket_finish_bind(socket)
|
|
3410
|
+
.into_answer()?
|
|
3411
|
+
.expect("the bind settles");
|
|
3412
|
+
let peer_address = ipv4((127, 0, 0, 1), port);
|
|
3413
|
+
let (_, outgoing) = guest
|
|
3414
|
+
.udp_udp_socket_stream(socket, Some(peer_address))
|
|
3415
|
+
.into_answer()?
|
|
3416
|
+
.expect("the udp endpoint names the peer");
|
|
3417
|
+
let room = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
3418
|
+
guest.poll_pollable_block(room)?;
|
|
3419
|
+
guest
|
|
3420
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
3421
|
+
.into_answer()?
|
|
3422
|
+
.expect("the stream with room permits a datagram");
|
|
3423
|
+
let sent = guest
|
|
3424
|
+
.udp_outgoing_datagram_stream_send(
|
|
3425
|
+
outgoing,
|
|
3426
|
+
vec![OutgoingDatagram {
|
|
3427
|
+
data: vec![0; MAX_DATAGRAM + 1],
|
|
3428
|
+
remote_address: None,
|
|
3429
|
+
}],
|
|
3430
|
+
)
|
|
3431
|
+
.into_answer()?;
|
|
3432
|
+
let elsewhere = ipv4((127, 0, 0, 2), port);
|
|
3433
|
+
guest
|
|
3434
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
3435
|
+
.into_answer()?
|
|
3436
|
+
.expect("the stream with room permits a datagram");
|
|
3437
|
+
let misaddressed = guest
|
|
3438
|
+
.udp_outgoing_datagram_stream_send(
|
|
3439
|
+
outgoing,
|
|
3440
|
+
vec![OutgoingDatagram {
|
|
3441
|
+
data: vec![0; MAX_DATAGRAM + 1],
|
|
3442
|
+
remote_address: Some(elsewhere),
|
|
3443
|
+
}],
|
|
3444
|
+
)
|
|
3445
|
+
.into_answer()?;
|
|
3446
|
+
Ok::<_, wasmtime::Error>((sent, misaddressed))
|
|
3447
|
+
})
|
|
3448
|
+
.expect("the send answers");
|
|
3449
|
+
assert!(
|
|
3450
|
+
matches!(
|
|
3451
|
+
sent,
|
|
3452
|
+
(
|
|
3453
|
+
Err(ErrorCode::DatagramTooLarge),
|
|
3454
|
+
Err(ErrorCode::DatagramTooLarge)
|
|
3455
|
+
)
|
|
3456
|
+
),
|
|
3457
|
+
"outgoing-datagram-stream.send of one byte past what IPv4 UDP carries must answer \
|
|
3458
|
+
datagram-too-large, as udp_sendmsg answers EMSGSIZE, even to an address other than \
|
|
3459
|
+
the peer, as wasmtime judges the size first, not {sent:?}"
|
|
3460
|
+
);
|
|
3461
|
+
}
|
|
3462
|
+
|
|
3463
|
+
// @behavior NW-072
|
|
3464
|
+
#[test]
|
|
3465
|
+
fn a_datagram_send_past_its_permit_traps() {
|
|
3466
|
+
let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
|
|
3467
|
+
let port = peer.local_addr().unwrap().port();
|
|
3468
|
+
let mut guest = network_guest(
|
|
3469
|
+
network::Endpoint::new("127.0.0.1", port)
|
|
3470
|
+
.unwrap()
|
|
3471
|
+
.with_protocol(network::Protocol::Udp),
|
|
3472
|
+
);
|
|
3473
|
+
let ping = || {
|
|
3474
|
+
vec![OutgoingDatagram {
|
|
3475
|
+
data: b"ping".to_vec(),
|
|
3476
|
+
remote_address: None,
|
|
3477
|
+
}]
|
|
3478
|
+
};
|
|
3479
|
+
let (unpermitted, permit, sent, spent) = run_task(
|
|
3480
|
+
Some(Instant::now() + Duration::from_secs(10)),
|
|
3481
|
+
|| -> wasmtime::Result<_> {
|
|
3482
|
+
let network = guest.instance_network_instance_network()?;
|
|
3483
|
+
let socket = guest
|
|
3484
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
3485
|
+
.into_answer()?
|
|
3486
|
+
.expect("a network makes a socket");
|
|
3487
|
+
guest
|
|
3488
|
+
.udp_udp_socket_start_bind(
|
|
3489
|
+
socket,
|
|
3490
|
+
network,
|
|
3491
|
+
IpSocketAddress::Ipv4(Ipv4SocketAddress {
|
|
3492
|
+
port: 0,
|
|
3493
|
+
address: (0, 0, 0, 0),
|
|
3494
|
+
}),
|
|
3495
|
+
)
|
|
3496
|
+
.into_answer()?
|
|
3497
|
+
.expect("an ephemeral bind is the implicit one");
|
|
3498
|
+
guest
|
|
3499
|
+
.udp_udp_socket_finish_bind(socket)
|
|
3500
|
+
.into_answer()?
|
|
3501
|
+
.expect("the bind settles");
|
|
3502
|
+
let (_incoming, outgoing) = guest
|
|
3503
|
+
.udp_udp_socket_stream(
|
|
3504
|
+
socket,
|
|
3505
|
+
Some(IpSocketAddress::Ipv4(Ipv4SocketAddress {
|
|
3506
|
+
port,
|
|
3507
|
+
address: (127, 0, 0, 1),
|
|
3508
|
+
})),
|
|
3509
|
+
)
|
|
3510
|
+
.into_answer()?
|
|
3511
|
+
.expect("the udp endpoint names the peer");
|
|
3512
|
+
let room = guest.udp_outgoing_datagram_stream_subscribe(outgoing)?;
|
|
3513
|
+
guest.poll_pollable_block(room)?;
|
|
3514
|
+
let unpermitted = guest
|
|
3515
|
+
.udp_outgoing_datagram_stream_send(outgoing, ping())
|
|
3516
|
+
.into_answer()
|
|
3517
|
+
.is_err();
|
|
3518
|
+
let permit = guest
|
|
3519
|
+
.udp_outgoing_datagram_stream_check_send(outgoing)
|
|
3520
|
+
.into_answer()?;
|
|
3521
|
+
let sent = guest
|
|
3522
|
+
.udp_outgoing_datagram_stream_send(outgoing, ping())
|
|
3523
|
+
.into_answer()?;
|
|
3524
|
+
let spent = guest
|
|
3525
|
+
.udp_outgoing_datagram_stream_send(outgoing, ping())
|
|
3526
|
+
.into_answer()
|
|
3527
|
+
.is_err();
|
|
3528
|
+
wasmtime::Result::Ok((unpermitted, permit, sent, spent))
|
|
3529
|
+
},
|
|
3530
|
+
)
|
|
3531
|
+
.expect("the socket streams with its peer");
|
|
3532
|
+
assert_eq!(
|
|
3533
|
+
(unpermitted, permit, sent, spent),
|
|
3534
|
+
(true, Ok(16), Ok(1), true),
|
|
3535
|
+
"outgoing-datagram-stream.send must trap before any check-send and once its permit \
|
|
3536
|
+
is spent, and send what check-send permitted, sixteen while the queue has room"
|
|
3537
|
+
);
|
|
3538
|
+
}
|
|
3539
|
+
|
|
3540
|
+
// @behavior NW-073
|
|
3541
|
+
#[test]
|
|
3542
|
+
fn a_blocking_write_past_4096_bytes_traps() {
|
|
3543
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
3544
|
+
let mut guest = loopback_guest(listener.local_addr().unwrap().port());
|
|
3545
|
+
let answers = run_task(
|
|
3546
|
+
Some(Instant::now() + Duration::from_secs(10)),
|
|
3547
|
+
|| -> wasmtime::Result<_> {
|
|
3548
|
+
let socket = guest
|
|
3549
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3550
|
+
.into_answer()?
|
|
3551
|
+
.expect("a network makes a socket");
|
|
3552
|
+
let network = guest.instance_network_instance_network()?;
|
|
3553
|
+
let remote = ipv4((127, 0, 0, 1), listener.local_addr().unwrap().port());
|
|
3554
|
+
guest
|
|
3555
|
+
.tcp_tcp_socket_start_connect(socket, network, remote)
|
|
3556
|
+
.into_answer()?
|
|
3557
|
+
.expect("an endpoint names the address");
|
|
3558
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3559
|
+
guest.poll_pollable_block(connecting)?;
|
|
3560
|
+
let (_input, output) = guest
|
|
3561
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3562
|
+
.into_answer()?
|
|
3563
|
+
.expect("the listener accepts");
|
|
3564
|
+
let past = guest
|
|
3565
|
+
.streams_output_stream_blocking_write_and_flush(output, vec![0; 4097])
|
|
3566
|
+
.into_answer()
|
|
3567
|
+
.is_err();
|
|
3568
|
+
let within = guest
|
|
3569
|
+
.streams_output_stream_blocking_write_and_flush(output, vec![0; 4096])
|
|
3570
|
+
.into_answer()
|
|
3571
|
+
.map(|answer| answer.is_ok())?;
|
|
3572
|
+
wasmtime::Result::Ok((past, within))
|
|
3573
|
+
},
|
|
3574
|
+
)
|
|
3575
|
+
.expect("the socket connects");
|
|
3576
|
+
assert_eq!(
|
|
3577
|
+
answers,
|
|
3578
|
+
(true, true),
|
|
3579
|
+
"output-stream.blocking-write-and-flush must trap on 4097 bytes, as io.wit bounds it, \
|
|
3580
|
+
and write 4096"
|
|
3581
|
+
);
|
|
3582
|
+
}
|
|
3583
|
+
|
|
3584
|
+
// @behavior NW-023
|
|
3585
|
+
#[test]
|
|
3586
|
+
fn a_frozen_clock_beside_a_socket_elapses_in_host_time() {
|
|
3587
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
3588
|
+
let mut guest = loopback_guest(listener.local_addr().unwrap().port());
|
|
3589
|
+
let started = Instant::now();
|
|
3590
|
+
let answer = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3591
|
+
let socket = guest
|
|
3592
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3593
|
+
.into_answer()?
|
|
3594
|
+
.expect("a network makes a socket");
|
|
3595
|
+
let network = guest.instance_network_instance_network()?;
|
|
3596
|
+
let remote = ipv4((127, 0, 0, 1), listener.local_addr().unwrap().port());
|
|
3597
|
+
guest
|
|
3598
|
+
.tcp_tcp_socket_start_connect(socket, network, remote)
|
|
3599
|
+
.into_answer()?
|
|
3600
|
+
.expect("an endpoint names the address");
|
|
3601
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3602
|
+
guest.poll_pollable_block(connecting)?;
|
|
3603
|
+
let (input, _output) = guest
|
|
3604
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3605
|
+
.into_answer()?
|
|
3606
|
+
.expect("the listener accepts");
|
|
3607
|
+
let silent = guest.streams_input_stream_subscribe(input)?;
|
|
3608
|
+
let clock = guest.monotonic_clock_subscribe_duration(50_000_000)?;
|
|
3609
|
+
guest.poll_poll(vec![silent, clock])
|
|
3610
|
+
})
|
|
3611
|
+
.expect("the poll answers");
|
|
3612
|
+
let spent = started.elapsed();
|
|
3613
|
+
assert!(
|
|
3614
|
+
answer == vec![1] && spent >= Duration::from_millis(50),
|
|
3615
|
+
"poll of a silent socket beside fifty milliseconds of subscribe-duration at the \
|
|
3616
|
+
hermetic profile must answer the clock once they pass, got {answer:?} after \
|
|
3617
|
+
{spent:?}"
|
|
3618
|
+
);
|
|
3619
|
+
}
|
|
3620
|
+
|
|
3621
|
+
// @behavior RT-382
|
|
3622
|
+
#[test]
|
|
3623
|
+
fn a_clock_past_what_the_host_counts_waits_until_the_deadline() {
|
|
3624
|
+
let (mut store, _) = guest(Profile::Permissive, None);
|
|
3625
|
+
let guest = store.data_mut();
|
|
3626
|
+
let started = Instant::now();
|
|
3627
|
+
let waited = run_task(Some(started + Duration::from_millis(100)), || {
|
|
3628
|
+
let clock = guest.monotonic_clock_subscribe_duration(u64::MAX)?;
|
|
3629
|
+
guest.poll_pollable_block(clock)
|
|
3630
|
+
});
|
|
3631
|
+
assert!(
|
|
3632
|
+
waited.is_err() && started.elapsed() >= Duration::from_millis(100),
|
|
3633
|
+
"subscribe-duration of the largest duration through a permissive guest must hand out \
|
|
3634
|
+
a clock that only the deadline ends"
|
|
3635
|
+
);
|
|
3636
|
+
}
|
|
3637
|
+
|
|
3638
|
+
// @behavior RT-340
|
|
3639
|
+
#[test]
|
|
3640
|
+
fn a_poll_of_no_pollable_traps() {
|
|
3641
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
3642
|
+
assert!(
|
|
3643
|
+
call::<(i32, i32), ()>(&mut store, &instance, "poll", (0, 0)).is_err(),
|
|
3644
|
+
"poll of an empty list must trap"
|
|
3645
|
+
);
|
|
3646
|
+
}
|
|
3647
|
+
|
|
3648
|
+
// @behavior RT-341
|
|
3649
|
+
#[test]
|
|
3650
|
+
fn a_view_takes_no_file_of_the_open_file_limit() {
|
|
3651
|
+
let mut config = Config::for_profile(Profile::Hermetic);
|
|
3652
|
+
config.limits.open_file_limit = Some(3);
|
|
3653
|
+
config.limits.memory_limit = None;
|
|
3654
|
+
let (mut store, instance) = guest_of(config);
|
|
3655
|
+
let first = call::<i64, i32>(&mut store, &instance, "subscribe", 0);
|
|
3656
|
+
let guest = store.data_mut();
|
|
3657
|
+
let held = (1..crate::preview2::table::MAX_TABLE_ENTRIES)
|
|
3658
|
+
.map(|_| guest.monotonic_clock_subscribe_duration(0))
|
|
3659
|
+
.take_while(Result::is_ok)
|
|
3660
|
+
.count();
|
|
3661
|
+
let past = guest.monotonic_clock_subscribe_duration(0);
|
|
3662
|
+
assert_eq!(
|
|
3663
|
+
(first.is_ok(), held, past.is_err()),
|
|
3664
|
+
(true, crate::preview2::table::MAX_TABLE_ENTRIES - 4, true),
|
|
3665
|
+
"subscribe-duration with no memory limit and the open file limit filled by the \
|
|
3666
|
+
standard streams must hand out pollables until the table, the three streams \
|
|
3667
|
+
included, holds a million handles, then trap"
|
|
3668
|
+
);
|
|
3669
|
+
}
|
|
3670
|
+
|
|
3671
|
+
// @behavior RT-394
|
|
3672
|
+
#[test]
|
|
3673
|
+
fn each_handle_takes_its_room_from_the_memory_limit() {
|
|
3674
|
+
let mut guest =
|
|
3675
|
+
Invocation::hermetic(None, |config| config.limits.memory_limit = Some(64 << 10));
|
|
3676
|
+
let held = (0..crate::preview2::table::MAX_TABLE_ENTRIES)
|
|
3677
|
+
.map_while(|_| guest.monotonic_clock_subscribe_duration(0).ok())
|
|
3678
|
+
.collect::<Vec<_>>();
|
|
3679
|
+
let filled = held.len();
|
|
3680
|
+
let last = *held.last().expect("a 64 KiB limit must hold a handle");
|
|
3681
|
+
let dropped = guest.poll_pollable_drop(last).is_ok();
|
|
3682
|
+
let again = guest.monotonic_clock_subscribe_duration(0).is_ok();
|
|
3683
|
+
assert_eq!(
|
|
3684
|
+
(filled > 0 && filled < 64 << 10, dropped, again),
|
|
3685
|
+
(true, true, true),
|
|
3686
|
+
"subscribe-duration under a 64 KiB memory limit must trap once its handles fill the \
|
|
3687
|
+
limit, short of the table's capacity, and hand one out again once a handle drops"
|
|
3688
|
+
);
|
|
3689
|
+
}
|
|
3690
|
+
|
|
3691
|
+
// @behavior NW-069
|
|
3692
|
+
#[test]
|
|
3693
|
+
fn a_socket_past_the_open_file_limit_answers_new_socket_limit() {
|
|
3694
|
+
let endpoint = network::Endpoint::new("127.0.0.1", 9)
|
|
3695
|
+
.unwrap()
|
|
3696
|
+
.with_protocol(network::Protocol::Tcp);
|
|
3697
|
+
let mut guest = limited_network_guest([endpoint], Some(3));
|
|
3698
|
+
assert_eq!(
|
|
3699
|
+
(
|
|
3700
|
+
guest
|
|
3701
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3702
|
+
.into_answer()
|
|
3703
|
+
.ok()
|
|
3704
|
+
.and_then(|answer| answer.err()),
|
|
3705
|
+
guest
|
|
3706
|
+
.udp_create_socket_create_udp_socket(IpAddressFamily::Ipv4)
|
|
3707
|
+
.into_answer()
|
|
3708
|
+
.ok()
|
|
3709
|
+
.and_then(|answer| answer.err()),
|
|
3710
|
+
),
|
|
3711
|
+
(
|
|
3712
|
+
Some(ErrorCode::NewSocketLimit),
|
|
3713
|
+
Some(ErrorCode::NewSocketLimit)
|
|
3714
|
+
),
|
|
3715
|
+
"create-tcp-socket and create-udp-socket with the open file limit filled by the \
|
|
3716
|
+
standard streams must answer new-socket-limit, not trap"
|
|
3717
|
+
);
|
|
3718
|
+
}
|
|
3719
|
+
|
|
3720
|
+
// @behavior NW-146
|
|
3721
|
+
#[test]
|
|
3722
|
+
fn a_lookup_or_a_request_past_the_open_file_limit_answers_an_error() {
|
|
3723
|
+
use super::super::bindings::wasi_http_types_0_2_12::{ErrorCode as HttpErrorCode, Scheme};
|
|
3724
|
+
use super::super::bindings::HttpHost;
|
|
3725
|
+
let endpoint = network::Endpoint::new("example.com", 80).unwrap();
|
|
3726
|
+
let mut guest = limited_network_guest([endpoint], Some(3));
|
|
3727
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
3728
|
+
let lookup = guest
|
|
3729
|
+
.ip_name_lookup_resolve_addresses(network, "example.com".to_string())
|
|
3730
|
+
.into_answer()
|
|
3731
|
+
.ok()
|
|
3732
|
+
.and_then(|answer| answer.err());
|
|
3733
|
+
let headers = guest.types_fields_new().unwrap();
|
|
3734
|
+
let headers = guest.take_handle(headers).unwrap();
|
|
3735
|
+
let request = guest.types_outgoing_request_new(headers).unwrap();
|
|
3736
|
+
guest
|
|
3737
|
+
.types_outgoing_request_set_scheme(request, Some(Scheme::HTTP))
|
|
3738
|
+
.unwrap()
|
|
3739
|
+
.unwrap();
|
|
3740
|
+
guest
|
|
3741
|
+
.types_outgoing_request_set_authority(request, Some("example.com".to_string()))
|
|
3742
|
+
.unwrap()
|
|
3743
|
+
.unwrap();
|
|
3744
|
+
let request = guest.take_handle(request).unwrap();
|
|
3745
|
+
let sent = guest
|
|
3746
|
+
.outgoing_handler_handle(request, None)
|
|
3747
|
+
.into_answer()
|
|
3748
|
+
.ok()
|
|
3749
|
+
.and_then(|answer| answer.err());
|
|
3750
|
+
assert_eq!(
|
|
3751
|
+
(lookup, sent),
|
|
3752
|
+
(
|
|
3753
|
+
Some(ErrorCode::NewSocketLimit),
|
|
3754
|
+
Some(HttpErrorCode::ConnectionLimitReached)
|
|
3755
|
+
),
|
|
3756
|
+
"resolve-addresses and outgoing-handler.handle with the open file limit filled by \
|
|
3757
|
+
the standard streams must answer new-socket-limit and connection-limit-reached, \
|
|
3758
|
+
not trap"
|
|
3759
|
+
);
|
|
3760
|
+
}
|
|
3761
|
+
|
|
3762
|
+
// @behavior NW-069
|
|
3763
|
+
#[test]
|
|
3764
|
+
fn a_socket_with_one_file_left_connects_and_hands_out_its_streams() {
|
|
3765
|
+
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
|
3766
|
+
let port = listener.local_addr().unwrap().port();
|
|
3767
|
+
let endpoint = network::Endpoint::new("127.0.0.1", port)
|
|
3768
|
+
.unwrap()
|
|
3769
|
+
.with_protocol(network::Protocol::Tcp)
|
|
3770
|
+
.with_addresses(vec![network::Addresses::Local]);
|
|
3771
|
+
let mut guest = limited_network_guest([endpoint], Some(4));
|
|
3772
|
+
let started = Instant::now();
|
|
3773
|
+
let connected = run_task(Some(started + Duration::from_secs(10)), || {
|
|
3774
|
+
let network = guest.instance_network_instance_network()?;
|
|
3775
|
+
let socket = guest
|
|
3776
|
+
.tcp_create_socket_create_tcp_socket(IpAddressFamily::Ipv4)
|
|
3777
|
+
.into_answer()?
|
|
3778
|
+
.expect("one file is left for the socket");
|
|
3779
|
+
let remote = ipv4((127, 0, 0, 1), port);
|
|
3780
|
+
guest
|
|
3781
|
+
.tcp_tcp_socket_start_connect(socket, network, remote)
|
|
3782
|
+
.into_answer()?
|
|
3783
|
+
.expect("the endpoint names the listener");
|
|
3784
|
+
let connecting = guest.tcp_tcp_socket_subscribe(socket)?;
|
|
3785
|
+
guest.poll_pollable_block(connecting)?;
|
|
3786
|
+
Ok::<_, wasmtime::Error>(
|
|
3787
|
+
guest
|
|
3788
|
+
.tcp_tcp_socket_finish_connect(socket)
|
|
3789
|
+
.into_answer()?
|
|
3790
|
+
.is_ok(),
|
|
3791
|
+
)
|
|
3792
|
+
});
|
|
3793
|
+
assert!(
|
|
3794
|
+
matches!(connected, Ok(true)),
|
|
3795
|
+
"a TCP socket made with one file left under the open file limit must connect and \
|
|
3796
|
+
hand out its streams, as Linux's connect takes no fd, not {connected:?}"
|
|
3797
|
+
);
|
|
3798
|
+
}
|
|
3799
|
+
|
|
3800
|
+
/// The preview2 functions a test answers before a Guest Binary imports
|
|
3801
|
+
/// them, each beside the test that holds the answer.
|
|
3802
|
+
const UNIMPORTED_ANSWERS: [(&str, &str, &str); 5] = [
|
|
3803
|
+
(
|
|
3804
|
+
"wasi:sockets/tcp@0.2.12",
|
|
3805
|
+
"[method]tcp-socket.remote-address",
|
|
3806
|
+
"a_looked_up_name_connects_and_reads_back_its_virtual_address",
|
|
3807
|
+
),
|
|
3808
|
+
(
|
|
3809
|
+
"wasi:http/types@0.2.12",
|
|
3810
|
+
"[method]request-options.connect-timeout",
|
|
3811
|
+
"request_options_read_back_their_timeouts_and_bound_the_wait_for_the_head",
|
|
3812
|
+
),
|
|
3813
|
+
(
|
|
3814
|
+
"wasi:http/types@0.2.12",
|
|
3815
|
+
"[method]request-options.first-byte-timeout",
|
|
3816
|
+
"request_options_read_back_their_timeouts_and_bound_the_wait_for_the_head",
|
|
3817
|
+
),
|
|
3818
|
+
(
|
|
3819
|
+
"wasi:http/types@0.2.12",
|
|
3820
|
+
"[method]request-options.between-bytes-timeout",
|
|
3821
|
+
"request_options_read_back_their_timeouts_and_bound_the_wait_for_the_head",
|
|
3822
|
+
),
|
|
3823
|
+
(
|
|
3824
|
+
"wasi:http/types@0.2.12",
|
|
3825
|
+
"[method]request-options.set-between-bytes-timeout",
|
|
3826
|
+
"request_options_read_back_their_timeouts_and_bound_the_wait_for_the_head",
|
|
3827
|
+
),
|
|
3828
|
+
];
|
|
3829
|
+
|
|
3830
|
+
#[test]
|
|
3831
|
+
fn the_driver_links_only_the_preview2_functions_a_guest_or_a_scenario_calls() {
|
|
3832
|
+
let data = std::path::Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../data"));
|
|
3833
|
+
let binaries = std::fs::read_dir(data)
|
|
3834
|
+
.map(|dir| {
|
|
3835
|
+
dir.filter_map(Result::ok)
|
|
3836
|
+
.map(|entry| entry.path())
|
|
3837
|
+
.filter(|path| path.extension().is_some_and(|ext| ext == "wasm"))
|
|
3838
|
+
.collect::<Vec<_>>()
|
|
3839
|
+
})
|
|
3840
|
+
.unwrap_or_default();
|
|
3841
|
+
if !crate::guest_binary::built(!binaries.is_empty(), "data/*.wasm") {
|
|
3842
|
+
return;
|
|
3843
|
+
}
|
|
3844
|
+
let preview2 = |module: &str| module.starts_with("wasi:") && module.contains("@0.2");
|
|
3845
|
+
let mut imported = std::collections::BTreeSet::new();
|
|
3846
|
+
for binary in &binaries {
|
|
3847
|
+
let module = crate::cache::load_module(binary).expect("a Guest Binary must load");
|
|
3848
|
+
for import in module.imports().filter(|import| preview2(import.module())) {
|
|
3849
|
+
imported.insert((import.module().to_string(), import.name().to_string()));
|
|
3850
|
+
}
|
|
3851
|
+
}
|
|
3852
|
+
let (mut store, _) = guest(Profile::Hermetic, None);
|
|
3853
|
+
let linker = imports::linker().expect("host imports must link");
|
|
3854
|
+
let linked = linker
|
|
3855
|
+
.iter(&mut store)
|
|
3856
|
+
.filter(|(module, _, _)| preview2(module))
|
|
3857
|
+
.map(|(module, name, _)| (module.to_string(), name.to_string()))
|
|
3858
|
+
.collect::<std::collections::BTreeSet<_>>();
|
|
3859
|
+
let unimported = UNIMPORTED_ANSWERS
|
|
3860
|
+
.iter()
|
|
3861
|
+
.map(|(module, name, _)| (module.to_string(), name.to_string()))
|
|
3862
|
+
.collect::<std::collections::BTreeSet<_>>();
|
|
3863
|
+
let expected = imported
|
|
3864
|
+
.union(&unimported)
|
|
3865
|
+
.cloned()
|
|
3866
|
+
.collect::<std::collections::BTreeSet<_>>();
|
|
3867
|
+
assert_eq!(
|
|
3868
|
+
linked, expected,
|
|
3869
|
+
"the Wasm Driver must link exactly the preview2 functions some data/*.wasm imports \
|
|
3870
|
+
and those a scenario answers ahead of the guest"
|
|
3871
|
+
);
|
|
3872
|
+
}
|
|
3873
|
+
|
|
3874
|
+
// @behavior NW-230
|
|
3875
|
+
#[test]
|
|
3876
|
+
fn a_stream_failure_downcasts_to_the_code_a_socket_call_answers() {
|
|
3877
|
+
let (mut store, _) = guest(Profile::Hermetic, None);
|
|
3878
|
+
let guest = store.data_mut();
|
|
3879
|
+
let failure = guest
|
|
3880
|
+
.table_mut()
|
|
3881
|
+
.push(io::Error(Errno::ConnectionReset))
|
|
3882
|
+
.unwrap();
|
|
3883
|
+
let code = guest.network_network_error_code(failure).unwrap();
|
|
3884
|
+
let described = guest.error_error_to_debug_string(failure).unwrap();
|
|
3885
|
+
assert_eq!(
|
|
3886
|
+
(code, described.as_str()),
|
|
3887
|
+
(Some(ErrorCode::ConnectionReset), "ECONNRESET"),
|
|
3888
|
+
"network-error-code on a stream's ECONNRESET must answer connection-reset, as a socket \
|
|
3889
|
+
call's failure does, while to-debug-string still names it for people"
|
|
3890
|
+
);
|
|
3891
|
+
}
|
|
3892
|
+
|
|
3893
|
+
// @behavior RT-347
|
|
3894
|
+
#[test]
|
|
3895
|
+
fn a_handle_numbers_apart_from_the_descriptors() {
|
|
3896
|
+
let (mut store, _) = guest(Profile::Hermetic, None);
|
|
3897
|
+
let guest = store.data_mut();
|
|
3898
|
+
let first = guest.instance_network_instance_network().unwrap();
|
|
3899
|
+
let next_descriptor = guest.wasi().descriptors().lowest_unused();
|
|
3900
|
+
guest.network_network_drop(first).unwrap();
|
|
3901
|
+
let again = guest.instance_network_instance_network().unwrap();
|
|
3902
|
+
assert_eq!(
|
|
3903
|
+
(first.0, next_descriptor, again.0),
|
|
3904
|
+
(4, Some(3), 4),
|
|
3905
|
+
"a guest holding only stdin, stdout, and stderr, which the resource table holds as \
|
|
3906
|
+
handles 1 to 3, must take 4 for its first preview2 handle, still find 3 as \
|
|
3907
|
+
preview1's next descriptor, and take 4 again once it is freed"
|
|
3908
|
+
);
|
|
3909
|
+
}
|
|
3910
|
+
|
|
3911
|
+
// @behavior RT-383
|
|
3912
|
+
#[test]
|
|
3913
|
+
fn preview1_reaches_no_socket_and_no_preview2_handle() {
|
|
3914
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
3915
|
+
let handles: Vec<i32> = (0..3)
|
|
3916
|
+
.map(|_| call::<(), i32>(&mut store, &instance, "network", ()).expect("a network"))
|
|
3917
|
+
.collect();
|
|
3918
|
+
let mut on = |name: &str, fd: i32| {
|
|
3919
|
+
call::<i32, i32>(&mut store, &instance, name, fd).expect("the call answers")
|
|
3920
|
+
};
|
|
3921
|
+
let calls = ["sock_accept", "sock_recv", "sock_send", "sock_shutdown"];
|
|
3922
|
+
let on_stdout = calls.map(|name| on(name, 1));
|
|
3923
|
+
let on_handle = (on("fdstat", handles[0]), on("sock_shutdown", handles[0]));
|
|
3924
|
+
assert_eq!(
|
|
3925
|
+
(handles, on_stdout, on_handle),
|
|
3926
|
+
(vec![4, 5, 6], [57; 4], (8, 8)),
|
|
3927
|
+
"sock_accept, sock_recv, sock_send, and sock_shutdown on stdout must answer \
|
|
3928
|
+
ENOTSOCK, as a preview1 descriptor is always a file, and preview1 calls on 4, a \
|
|
3929
|
+
number only a preview2 handle holds, must answer EBADF"
|
|
3930
|
+
);
|
|
3931
|
+
}
|
|
3932
|
+
|
|
3933
|
+
// @behavior RT-348
|
|
3934
|
+
#[test]
|
|
3935
|
+
fn a_drop_of_a_handle_as_another_kind_traps() {
|
|
3936
|
+
let (mut store, _) = guest(Profile::Hermetic, None);
|
|
3937
|
+
let guest = store.data_mut();
|
|
3938
|
+
let network = guest.instance_network_instance_network().unwrap();
|
|
3939
|
+
let wrong = guest.tcp_tcp_socket_drop(TcpSocket(network.0)).is_err();
|
|
3940
|
+
let kept = guest.table_mut().get(network).is_ok();
|
|
3941
|
+
assert!(
|
|
3942
|
+
wrong && kept,
|
|
3943
|
+
"tcp-socket's drop of a network handle must trap and leave the network held"
|
|
3944
|
+
);
|
|
3945
|
+
}
|
|
3946
|
+
|
|
3947
|
+
// @behavior RT-348
|
|
3948
|
+
#[test]
|
|
3949
|
+
fn a_handle_of_another_kind_where_a_network_is_taken_traps() {
|
|
3950
|
+
let (mut store, instance) = guest(Profile::Hermetic, None);
|
|
3951
|
+
let pollable = call::<i64, i32>(&mut store, &instance, "subscribe", 0).expect("a pollable");
|
|
3952
|
+
let answer = call::<(i32, i32), ()>(&mut store, &instance, "resolve", (pollable, 0));
|
|
3953
|
+
assert!(
|
|
3954
|
+
answer.is_err(),
|
|
3955
|
+
"resolve-addresses handed a pollable where its network is taken must trap, not \
|
|
3956
|
+
answer an error-code"
|
|
3957
|
+
);
|
|
3958
|
+
}
|
|
3959
|
+
}
|