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