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.
Files changed (266) hide show
  1. checksums.yaml +4 -4
  2. data/.release-please-manifest.json +1 -1
  3. data/CHANGELOG.md +335 -0
  4. data/Cargo.lock +469 -11
  5. data/README.md +43 -3
  6. data/ROADMAP.md +1 -1
  7. data/crates/kobako-runtime/CHANGELOG.md +219 -0
  8. data/crates/kobako-runtime/Cargo.toml +51 -3
  9. data/crates/kobako-runtime/README.md +7 -4
  10. data/crates/kobako-runtime/src/cred.rs +124 -0
  11. data/crates/kobako-runtime/src/dispatch.rs +4 -5
  12. data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
  13. data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
  14. data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
  15. data/crates/kobako-runtime/src/endpoint.rs +137 -36
  16. data/crates/kobako-runtime/src/errno.rs +391 -0
  17. data/crates/kobako-runtime/src/error.rs +31 -10
  18. data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
  19. data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
  20. data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
  21. data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
  22. data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
  23. data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
  24. data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
  25. data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
  26. data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
  27. data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
  28. data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
  29. data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
  30. data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
  31. data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
  32. data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
  33. data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
  34. data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
  35. data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
  36. data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
  37. data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
  38. data/crates/kobako-runtime/src/filesystem.rs +6 -3
  39. data/crates/kobako-runtime/src/fork.rs +96 -0
  40. data/crates/kobako-runtime/src/grant.rs +3 -0
  41. data/crates/kobako-runtime/src/hashtable.rs +4 -2
  42. data/crates/kobako-runtime/src/lib.rs +18 -7
  43. data/crates/kobako-runtime/src/limits.rs +195 -0
  44. data/crates/kobako-runtime/src/locking.rs +10 -0
  45. data/crates/kobako-runtime/src/memcg.rs +383 -0
  46. data/crates/kobako-runtime/src/mount.rs +67 -9
  47. data/crates/kobako-runtime/src/net/backends.rs +43 -0
  48. data/crates/kobako-runtime/src/net/connections.rs +179 -0
  49. data/crates/kobako-runtime/src/net/credential.rs +125 -0
  50. data/crates/kobako-runtime/src/net/egress.rs +160 -0
  51. data/crates/kobako-runtime/src/net/family.rs +181 -0
  52. data/crates/kobako-runtime/src/net/http.rs +2733 -0
  53. data/crates/kobako-runtime/src/net/lookup.rs +285 -0
  54. data/crates/kobako-runtime/src/net/mock.rs +251 -0
  55. data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
  56. data/crates/kobako-runtime/src/net/reactor.rs +531 -0
  57. data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
  58. data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
  59. data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
  60. data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
  61. data/crates/kobako-runtime/src/net/resolv.rs +227 -0
  62. data/crates/kobako-runtime/src/net/socket.rs +870 -0
  63. data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
  64. data/crates/kobako-runtime/src/net/tls.rs +58 -0
  65. data/crates/kobako-runtime/src/net/transport.rs +279 -0
  66. data/crates/kobako-runtime/src/net/udp.rs +1003 -0
  67. data/crates/kobako-runtime/src/net.rs +42 -0
  68. data/crates/kobako-runtime/src/network/builder.rs +177 -0
  69. data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
  70. data/crates/kobako-runtime/src/network.rs +551 -0
  71. data/crates/kobako-runtime/src/policy.rs +16 -0
  72. data/crates/kobako-runtime/src/profile.rs +29 -144
  73. data/crates/kobako-runtime/src/runtime.rs +3 -5
  74. data/crates/kobako-runtime/src/sched.rs +130 -29
  75. data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
  76. data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
  77. data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
  78. data/crates/kobako-runtime/src/security.rs +101 -196
  79. data/crates/kobako-runtime/src/snapshot.rs +121 -2
  80. data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
  81. data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
  82. data/crates/kobako-runtime/src/vfs/file.rs +199 -203
  83. data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
  84. data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
  85. data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
  86. data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
  87. data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
  88. data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
  89. data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
  90. data/crates/kobako-runtime/src/vfs/path.rs +6 -6
  91. data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
  92. data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
  93. data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
  94. data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
  95. data/crates/kobako-runtime/src/vfs.rs +9 -6
  96. data/crates/kobako-runtime/src/wait.rs +356 -0
  97. data/crates/kobako-transport/CHANGELOG.md +31 -0
  98. data/crates/kobako-transport/Cargo.toml +1 -1
  99. data/crates/kobako-transport/README.md +3 -4
  100. data/crates/kobako-transport/src/abi.rs +78 -72
  101. data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
  102. data/crates/kobako-transport/src/envelope/call.rs +32 -4
  103. data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
  104. data/crates/kobako-transport/src/envelope/name.rs +99 -0
  105. data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
  106. data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
  107. data/crates/kobako-transport/src/envelope/reply.rs +27 -27
  108. data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
  109. data/crates/kobako-transport/src/envelope.rs +13 -8
  110. data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
  111. data/crates/kobako-wasmtime/Cargo.toml +26 -7
  112. data/crates/kobako-wasmtime/README.md +3 -2
  113. data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
  114. data/crates/kobako-wasmtime/build.rs +16 -0
  115. data/crates/kobako-wasmtime/src/abi.rs +17 -37
  116. data/crates/kobako-wasmtime/src/ambient.rs +33 -18
  117. data/crates/kobako-wasmtime/src/cache.rs +23 -15
  118. data/crates/kobako-wasmtime/src/config.rs +52 -68
  119. data/crates/kobako-wasmtime/src/driver.rs +48 -63
  120. data/crates/kobako-wasmtime/src/exports.rs +143 -17
  121. data/crates/kobako-wasmtime/src/guest.rs +12 -6
  122. data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
  123. data/crates/kobako-wasmtime/src/imports.rs +42 -18
  124. data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
  125. data/crates/kobako-wasmtime/src/invocation.rs +74 -12
  126. data/crates/kobako-wasmtime/src/lib.rs +5 -3
  127. data/crates/kobako-wasmtime/src/limiter.rs +70 -5
  128. data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
  129. data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
  130. data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
  131. data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
  132. data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
  133. data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
  134. data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
  135. data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
  136. data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
  137. data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
  138. data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
  139. data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
  140. data/crates/kobako-wasmtime/src/preview1.rs +46 -42
  141. data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
  142. data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
  143. data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
  144. data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
  145. data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
  146. data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
  147. data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
  148. data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
  149. data/crates/kobako-wasmtime/src/preview2.rs +57 -0
  150. data/crates/kobako-wasmtime/src/trap.rs +24 -9
  151. data/crates/kobako-wasmtime/src/wasi.rs +210 -81
  152. data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
  153. data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
  154. data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
  155. data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
  156. data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
  157. data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
  158. data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
  159. data/data/kobako.wasm +0 -0
  160. data/ext/kobako/Cargo.toml +1 -1
  161. data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
  162. data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
  163. data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
  164. data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
  165. data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
  166. data/ext/kobako/src/gvl.rs +306 -0
  167. data/ext/kobako/src/lib.rs +64 -3
  168. data/ext/kobako/src/network/mock.rs +187 -0
  169. data/ext/kobako/src/network.rs +591 -0
  170. data/ext/kobako/src/runtime/bridge.rs +30 -29
  171. data/ext/kobako/src/runtime/snapshot.rs +4 -4
  172. data/ext/kobako/src/runtime.rs +221 -143
  173. data/ext/kobako/src/wire.rs +42 -0
  174. data/lib/kobako/catalog/extensions.rb +14 -2
  175. data/lib/kobako/catalog/flags.rb +3 -5
  176. data/lib/kobako/catalog/grants.rb +5 -4
  177. data/lib/kobako/catalog/handles.rb +5 -27
  178. data/lib/kobako/catalog/mount.rb +11 -3
  179. data/lib/kobako/catalog/network.rb +35 -0
  180. data/lib/kobako/catalog/replacements.rb +28 -0
  181. data/lib/kobako/catalog/services.rb +5 -19
  182. data/lib/kobako/catalog/snippets.rb +3 -18
  183. data/lib/kobako/catalog.rb +3 -0
  184. data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
  185. data/lib/kobako/codec/decoder.rb +4 -4
  186. data/lib/kobako/codec/ext_types.rb +3 -3
  187. data/lib/kobako/codec/handle_walk.rb +3 -43
  188. data/lib/kobako/codec/value_budget.rb +132 -40
  189. data/lib/kobako/codec.rb +1 -1
  190. data/lib/kobako/context.rb +24 -11
  191. data/lib/kobako/errors.rb +15 -12
  192. data/lib/kobako/extension.rb +3 -2
  193. data/lib/kobako/filesystem.rb +9 -2
  194. data/lib/kobako/handle.rb +2 -2
  195. data/lib/kobako/names.rb +28 -0
  196. data/lib/kobako/network.rb +210 -0
  197. data/lib/kobako/outcome.rb +7 -7
  198. data/lib/kobako/pool.rb +45 -23
  199. data/lib/kobako/runtime.rb +3 -2
  200. data/lib/kobako/sandbox.rb +92 -35
  201. data/lib/kobako/sandbox_options.rb +41 -106
  202. data/lib/kobako/transport/argument_wrap.rb +64 -0
  203. data/lib/kobako/transport/block_failure.rb +1 -1
  204. data/lib/kobako/transport/dispatcher.rb +6 -6
  205. data/lib/kobako/transport/exposure.rb +26 -15
  206. data/lib/kobako/transport/reflection.rb +21 -4
  207. data/lib/kobako/transport/run.rb +8 -23
  208. data/lib/kobako/transport/yielder.rb +2 -9
  209. data/lib/kobako/transport.rb +1 -0
  210. data/lib/kobako/version.rb +1 -1
  211. data/lib/kobako.rb +6 -2
  212. data/release-please-config.json +15 -0
  213. data/sig/core/thread.rbs +6 -0
  214. data/sig/kobako/catalog/extensions.rbs +2 -0
  215. data/sig/kobako/catalog/grants.rbs +7 -4
  216. data/sig/kobako/catalog/handles.rbs +0 -2
  217. data/sig/kobako/catalog/mount.rbs +3 -1
  218. data/sig/kobako/catalog/network.rbs +20 -0
  219. data/sig/kobako/catalog/replacements.rbs +14 -0
  220. data/sig/kobako/catalog/services.rbs +0 -4
  221. data/sig/kobako/catalog/snippets.rbs +0 -2
  222. data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
  223. data/sig/kobako/codec/handle_walk.rbs +0 -6
  224. data/sig/kobako/codec/value_budget.rbs +47 -4
  225. data/sig/kobako/context.rbs +3 -1
  226. data/sig/kobako/errors.rbs +4 -4
  227. data/sig/kobako/filesystem.rbs +21 -3
  228. data/sig/kobako/network.rbs +115 -0
  229. data/sig/kobako/outcome.rbs +1 -1
  230. data/sig/kobako/pool.rbs +7 -3
  231. data/sig/kobako/runtime.rbs +32 -3
  232. data/sig/kobako/sandbox.rbs +19 -2
  233. data/sig/kobako/sandbox_options.rbs +29 -38
  234. data/sig/kobako/transport/argument_wrap.rbs +15 -0
  235. data/sig/kobako/transport/error.rbs +1 -1
  236. data/sig/kobako/transport/exposure.rbs +2 -4
  237. data/sig/kobako/transport/reflection.rbs +10 -0
  238. data/sig/kobako/transport/run.rbs +0 -2
  239. data/sig/kobako/transport/yielder.rbs +0 -3
  240. data/sig/kobako/transport.rbs +1 -1
  241. data/sig/kobako.rbs +13 -0
  242. metadata +84 -35
  243. data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
  244. data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
  245. data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
  246. data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
  247. data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
  248. data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
  249. data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
  250. data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
  251. data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
  252. data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
  253. data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
  254. data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
  255. data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
  256. data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
  257. data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
  258. data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
  259. data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
  260. data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
  261. data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
  262. data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
  263. data/ext/kobako/src/runtime/gvl.rs +0 -147
  264. data/lib/kobako/constant_name.rb +0 -8
  265. data/sig/kobako/constant_name.rbs +0 -3
  266. /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
+ }