kobako 0.30.0 → 0.31.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.release-please-manifest.json +1 -1
- data/CHANGELOG.md +335 -0
- data/Cargo.lock +469 -11
- data/README.md +43 -3
- data/ROADMAP.md +1 -1
- data/crates/kobako-runtime/CHANGELOG.md +219 -0
- data/crates/kobako-runtime/Cargo.toml +51 -3
- data/crates/kobako-runtime/README.md +7 -4
- data/crates/kobako-runtime/src/cred.rs +124 -0
- data/crates/kobako-runtime/src/dispatch.rs +4 -5
- data/crates/kobako-runtime/src/endpoint/buffer.rs +153 -44
- data/crates/kobako-runtime/src/endpoint/dispatch.rs +80 -41
- data/crates/kobako-runtime/src/endpoint/invoke.rs +23 -36
- data/crates/kobako-runtime/src/endpoint.rs +137 -36
- data/crates/kobako-runtime/src/errno.rs +391 -0
- data/crates/kobako-runtime/src/error.rs +31 -10
- data/crates/kobako-runtime/src/filesystem/anon_inodes.rs +52 -0
- data/crates/kobako-runtime/src/filesystem/bind/lookup.rs +52 -14
- data/crates/kobako-runtime/src/filesystem/bind/walk.rs +19 -20
- data/crates/kobako-runtime/src/filesystem/bind.rs +437 -245
- data/crates/kobako-runtime/src/filesystem/overlay/file.rs +6 -6
- data/crates/kobako-runtime/src/filesystem/overlay/path.rs +43 -65
- data/crates/kobako-runtime/src/filesystem/overlay/stack/copy_up.rs +9 -16
- data/crates/kobako-runtime/src/filesystem/overlay/stack/dir.rs +47 -72
- data/crates/kobako-runtime/src/filesystem/overlay/stack/namei.rs +12 -12
- data/crates/kobako-runtime/src/filesystem/overlay/stack/readdir.rs +4 -7
- data/crates/kobako-runtime/src/filesystem/overlay/stack.rs +121 -37
- data/crates/kobako-runtime/src/filesystem/overlay.rs +302 -343
- data/crates/kobako-runtime/src/filesystem/pipe.rs +12 -9
- data/crates/kobako-runtime/src/filesystem/rdir.rs +15 -32
- data/crates/kobako-runtime/src/filesystem/tmpfs/seed.rs +32 -0
- data/crates/kobako-runtime/src/filesystem/tmpfs/tmpfile.rs +3 -3
- data/crates/kobako-runtime/src/filesystem/tmpfs/whiteout.rs +57 -35
- data/crates/kobako-runtime/src/filesystem/tmpfs/xattr.rs +2 -2
- data/crates/kobako-runtime/src/filesystem/tmpfs.rs +172 -160
- data/crates/kobako-runtime/src/filesystem/wrap.rs +36 -52
- data/crates/kobako-runtime/src/filesystem.rs +6 -3
- data/crates/kobako-runtime/src/fork.rs +96 -0
- data/crates/kobako-runtime/src/grant.rs +3 -0
- data/crates/kobako-runtime/src/hashtable.rs +4 -2
- data/crates/kobako-runtime/src/lib.rs +18 -7
- data/crates/kobako-runtime/src/limits.rs +195 -0
- data/crates/kobako-runtime/src/locking.rs +10 -0
- data/crates/kobako-runtime/src/memcg.rs +383 -0
- data/crates/kobako-runtime/src/mount.rs +67 -9
- data/crates/kobako-runtime/src/net/backends.rs +43 -0
- data/crates/kobako-runtime/src/net/connections.rs +179 -0
- data/crates/kobako-runtime/src/net/credential.rs +125 -0
- data/crates/kobako-runtime/src/net/egress.rs +160 -0
- data/crates/kobako-runtime/src/net/family.rs +181 -0
- data/crates/kobako-runtime/src/net/http.rs +2733 -0
- data/crates/kobako-runtime/src/net/lookup.rs +285 -0
- data/crates/kobako-runtime/src/net/mock.rs +251 -0
- data/crates/kobako-runtime/src/net/namespace.rs +1366 -0
- data/crates/kobako-runtime/src/net/reactor.rs +531 -0
- data/crates/kobako-runtime/src/net/resolv/darwin.rs +275 -0
- data/crates/kobako-runtime/src/net/resolv/stub/tests.rs +469 -0
- data/crates/kobako-runtime/src/net/resolv/stub.rs +536 -0
- data/crates/kobako-runtime/src/net/resolv/windows.rs +248 -0
- data/crates/kobako-runtime/src/net/resolv.rs +227 -0
- data/crates/kobako-runtime/src/net/socket.rs +870 -0
- data/crates/kobako-runtime/src/net/tcp.rs +1588 -0
- data/crates/kobako-runtime/src/net/tls.rs +58 -0
- data/crates/kobako-runtime/src/net/transport.rs +279 -0
- data/crates/kobako-runtime/src/net/udp.rs +1003 -0
- data/crates/kobako-runtime/src/net.rs +42 -0
- data/crates/kobako-runtime/src/network/builder.rs +177 -0
- data/crates/kobako-runtime/src/network/ruleset.rs +777 -0
- data/crates/kobako-runtime/src/network.rs +551 -0
- data/crates/kobako-runtime/src/policy.rs +16 -0
- data/crates/kobako-runtime/src/profile.rs +29 -144
- data/crates/kobako-runtime/src/runtime.rs +3 -5
- data/crates/kobako-runtime/src/sched.rs +130 -29
- data/crates/kobako-runtime/src/security/entry_policy.rs +22 -0
- data/crates/kobako-runtime/src/{vfs/cred.rs → security/hooks.rs} +52 -144
- data/crates/kobako-runtime/src/security/mount_policy.rs +158 -0
- data/crates/kobako-runtime/src/security.rs +101 -196
- data/crates/kobako-runtime/src/snapshot.rs +121 -2
- data/crates/kobako-runtime/src/vfs/attr.rs +5 -5
- data/crates/kobako-runtime/src/vfs/dentry.rs +143 -89
- data/crates/kobako-runtime/src/vfs/file.rs +199 -203
- data/crates/kobako-runtime/src/vfs/inode.rs +41 -45
- data/crates/kobako-runtime/src/vfs/kern_path.rs +38 -42
- data/crates/kobako-runtime/src/vfs/mount.rs +10 -9
- data/crates/kobako-runtime/src/vfs/namei.rs +829 -700
- data/crates/kobako-runtime/src/vfs/namespace.rs +162 -0
- data/crates/kobako-runtime/src/vfs/open_files.rs +69 -0
- data/crates/kobako-runtime/src/vfs/openat2.rs +3 -3
- data/crates/kobako-runtime/src/vfs/path.rs +6 -6
- data/crates/kobako-runtime/src/vfs/readdir.rs +6 -6
- data/crates/kobako-runtime/src/vfs/stat.rs +159 -23
- data/crates/kobako-runtime/src/vfs/super_block.rs +18 -14
- data/crates/kobako-runtime/src/vfs/utimes.rs +37 -27
- data/crates/kobako-runtime/src/vfs.rs +9 -6
- data/crates/kobako-runtime/src/wait.rs +356 -0
- data/crates/kobako-transport/CHANGELOG.md +31 -0
- data/crates/kobako-transport/Cargo.toml +1 -1
- data/crates/kobako-transport/README.md +3 -4
- data/crates/kobako-transport/src/abi.rs +78 -72
- data/crates/kobako-transport/src/envelope/bytes.rs +17 -6
- data/crates/kobako-transport/src/envelope/call.rs +32 -4
- data/crates/kobako-transport/src/envelope/error_record.rs +21 -0
- data/crates/kobako-transport/src/envelope/name.rs +99 -0
- data/crates/kobako-transport/src/envelope/outcome.rs +9 -9
- data/crates/kobako-transport/src/envelope/preamble.rs +24 -21
- data/crates/kobako-transport/src/envelope/reply.rs +27 -27
- data/crates/kobako-transport/src/envelope/unsupported.rs +10 -10
- data/crates/kobako-transport/src/envelope.rs +13 -8
- data/crates/kobako-wasmtime/CHANGELOG.md +161 -0
- data/crates/kobako-wasmtime/Cargo.toml +26 -7
- data/crates/kobako-wasmtime/README.md +3 -2
- data/crates/kobako-wasmtime/build/preview2.rs +1339 -0
- data/crates/kobako-wasmtime/build.rs +16 -0
- data/crates/kobako-wasmtime/src/abi.rs +17 -37
- data/crates/kobako-wasmtime/src/ambient.rs +33 -18
- data/crates/kobako-wasmtime/src/cache.rs +23 -15
- data/crates/kobako-wasmtime/src/config.rs +52 -68
- data/crates/kobako-wasmtime/src/driver.rs +48 -63
- data/crates/kobako-wasmtime/src/exports.rs +143 -17
- data/crates/kobako-wasmtime/src/guest.rs +12 -6
- data/crates/kobako-wasmtime/src/guest_binary.rs +14 -0
- data/crates/kobako-wasmtime/src/imports.rs +42 -18
- data/crates/kobako-wasmtime/src/instance_pre.rs +4 -4
- data/crates/kobako-wasmtime/src/invocation.rs +74 -12
- data/crates/kobako-wasmtime/src/lib.rs +5 -3
- data/crates/kobako-wasmtime/src/limiter.rs +70 -5
- data/crates/kobako-wasmtime/src/preview1/descriptors.rs +309 -0
- data/crates/kobako-wasmtime/src/preview1/differential/mount.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1/differential.rs +27 -31
- data/crates/kobako-wasmtime/src/preview1/errno.rs +55 -66
- data/crates/kobako-wasmtime/src/preview1/fd.rs +327 -296
- data/crates/kobako-wasmtime/src/preview1/memory.rs +21 -12
- data/crates/kobako-wasmtime/src/preview1/mount_view/wrap.rs +34 -53
- data/crates/kobako-wasmtime/src/preview1/mount_view.rs +231 -217
- data/crates/kobako-wasmtime/src/preview1/path.rs +56 -121
- data/crates/kobako-wasmtime/src/preview1/poll.rs +244 -120
- data/crates/kobako-wasmtime/src/preview1/sock.rs +10 -8
- data/crates/kobako-wasmtime/src/preview1/testsuite.rs +5 -15
- data/crates/kobako-wasmtime/src/preview1.rs +46 -42
- data/crates/kobako-wasmtime/src/preview2/abi.rs +227 -0
- data/crates/kobako-wasmtime/src/preview2/error.rs +118 -0
- data/crates/kobako-wasmtime/src/preview2/filesystem.rs +122 -0
- data/crates/kobako-wasmtime/src/preview2/host.rs +3959 -0
- data/crates/kobako-wasmtime/src/preview2/http.rs +1503 -0
- data/crates/kobako-wasmtime/src/preview2/io.rs +315 -0
- data/crates/kobako-wasmtime/src/preview2/sockets.rs +379 -0
- data/crates/kobako-wasmtime/src/preview2/table.rs +305 -0
- data/crates/kobako-wasmtime/src/preview2.rs +57 -0
- data/crates/kobako-wasmtime/src/trap.rs +24 -9
- data/crates/kobako-wasmtime/src/wasi.rs +210 -81
- data/crates/kobako-wasmtime/wit/deps/cli.wit +233 -0
- data/crates/kobako-wasmtime/wit/deps/clocks.wit +162 -0
- data/crates/kobako-wasmtime/wit/deps/filesystem.wit +589 -0
- data/crates/kobako-wasmtime/wit/deps/http.wit +733 -0
- data/crates/kobako-wasmtime/wit/deps/io.wit +299 -0
- data/crates/kobako-wasmtime/wit/deps/random.wit +92 -0
- data/crates/kobako-wasmtime/wit/deps/sockets.wit +949 -0
- data/data/kobako.wasm +0 -0
- data/ext/kobako/Cargo.toml +1 -1
- data/ext/kobako/src/{runtime/errors.rs → errors.rs} +34 -26
- data/ext/kobako/src/{runtime/escape.rs → escape.rs} +42 -11
- data/ext/kobako/src/{runtime/filesystem → filesystem}/grants.rs +30 -26
- data/ext/kobako/src/{runtime/filesystem → filesystem}/ruby.rs +149 -168
- data/ext/kobako/src/{runtime/filesystem.rs → filesystem.rs} +24 -15
- data/ext/kobako/src/gvl.rs +306 -0
- data/ext/kobako/src/lib.rs +64 -3
- data/ext/kobako/src/network/mock.rs +187 -0
- data/ext/kobako/src/network.rs +591 -0
- data/ext/kobako/src/runtime/bridge.rs +30 -29
- data/ext/kobako/src/runtime/snapshot.rs +4 -4
- data/ext/kobako/src/runtime.rs +221 -143
- data/ext/kobako/src/wire.rs +42 -0
- data/lib/kobako/catalog/extensions.rb +14 -2
- data/lib/kobako/catalog/flags.rb +3 -5
- data/lib/kobako/catalog/grants.rb +5 -4
- data/lib/kobako/catalog/handles.rb +5 -27
- data/lib/kobako/catalog/mount.rb +11 -3
- data/lib/kobako/catalog/network.rb +35 -0
- data/lib/kobako/catalog/replacements.rb +28 -0
- data/lib/kobako/catalog/services.rb +5 -19
- data/lib/kobako/catalog/snippets.rb +3 -18
- data/lib/kobako/catalog.rb +3 -0
- data/lib/kobako/codec/{utils.rb → boundary.rb} +4 -2
- data/lib/kobako/codec/decoder.rb +4 -4
- data/lib/kobako/codec/ext_types.rb +3 -3
- data/lib/kobako/codec/handle_walk.rb +3 -43
- data/lib/kobako/codec/value_budget.rb +132 -40
- data/lib/kobako/codec.rb +1 -1
- data/lib/kobako/context.rb +24 -11
- data/lib/kobako/errors.rb +15 -12
- data/lib/kobako/extension.rb +3 -2
- data/lib/kobako/filesystem.rb +9 -2
- data/lib/kobako/handle.rb +2 -2
- data/lib/kobako/names.rb +28 -0
- data/lib/kobako/network.rb +210 -0
- data/lib/kobako/outcome.rb +7 -7
- data/lib/kobako/pool.rb +45 -23
- data/lib/kobako/runtime.rb +3 -2
- data/lib/kobako/sandbox.rb +92 -35
- data/lib/kobako/sandbox_options.rb +41 -106
- data/lib/kobako/transport/argument_wrap.rb +64 -0
- data/lib/kobako/transport/block_failure.rb +1 -1
- data/lib/kobako/transport/dispatcher.rb +6 -6
- data/lib/kobako/transport/exposure.rb +26 -15
- data/lib/kobako/transport/reflection.rb +21 -4
- data/lib/kobako/transport/run.rb +8 -23
- data/lib/kobako/transport/yielder.rb +2 -9
- data/lib/kobako/transport.rb +1 -0
- data/lib/kobako/version.rb +1 -1
- data/lib/kobako.rb +6 -2
- data/release-please-config.json +15 -0
- data/sig/core/thread.rbs +6 -0
- data/sig/kobako/catalog/extensions.rbs +2 -0
- data/sig/kobako/catalog/grants.rbs +7 -4
- data/sig/kobako/catalog/handles.rbs +0 -2
- data/sig/kobako/catalog/mount.rbs +3 -1
- data/sig/kobako/catalog/network.rbs +20 -0
- data/sig/kobako/catalog/replacements.rbs +14 -0
- data/sig/kobako/catalog/services.rbs +0 -4
- data/sig/kobako/catalog/snippets.rbs +0 -2
- data/sig/kobako/codec/{utils.rbs → boundary.rbs} +2 -2
- data/sig/kobako/codec/handle_walk.rbs +0 -6
- data/sig/kobako/codec/value_budget.rbs +47 -4
- data/sig/kobako/context.rbs +3 -1
- data/sig/kobako/errors.rbs +4 -4
- data/sig/kobako/filesystem.rbs +21 -3
- data/sig/kobako/network.rbs +115 -0
- data/sig/kobako/outcome.rbs +1 -1
- data/sig/kobako/pool.rbs +7 -3
- data/sig/kobako/runtime.rbs +32 -3
- data/sig/kobako/sandbox.rbs +19 -2
- data/sig/kobako/sandbox_options.rbs +29 -38
- data/sig/kobako/transport/argument_wrap.rbs +15 -0
- data/sig/kobako/transport/error.rbs +1 -1
- data/sig/kobako/transport/exposure.rbs +2 -4
- data/sig/kobako/transport/reflection.rbs +10 -0
- data/sig/kobako/transport/run.rbs +0 -2
- data/sig/kobako/transport/yielder.rbs +0 -3
- data/sig/kobako/transport.rbs +1 -1
- data/sig/kobako.rbs +13 -0
- metadata +84 -35
- data/crates/kobako-runtime/src/endpoint/capture.rs +0 -115
- data/crates/kobako-runtime/src/endpoint/memory_cap.rs +0 -238
- data/crates/kobako-runtime/src/filesystem/path.rs +0 -21
- data/crates/kobako-runtime/src/vfs/errno.rs +0 -153
- data/crates/kobako-runtime/tests/linux_baseline/calls.rs +0 -171
- data/crates/kobako-runtime/tests/linux_baseline/concurrent.rs +0 -276
- data/crates/kobako-runtime/tests/linux_baseline/kobako.rs +0 -323
- data/crates/kobako-runtime/tests/linux_baseline/linux-baseline-expected.txt +0 -16
- data/crates/kobako-runtime/tests/linux_baseline/linux.rs +0 -449
- data/crates/kobako-runtime/tests/linux_baseline/main.rs +0 -611
- data/crates/kobako-runtime/tests/linux_baseline/permissions.rs +0 -236
- data/crates/kobako-wasmtime/src/descriptors.rs +0 -200
- data/crates/kobako-wasmtime/tests/integration/compile_posture.rs +0 -43
- data/crates/kobako-wasmtime/tests/integration/guest_file.rs +0 -1085
- data/crates/kobako-wasmtime/tests/integration/main.rs +0 -29
- data/crates/kobako-wasmtime/tests/integration/preamble_flags.rs +0 -70
- data/crates/kobako-wasmtime/tests/integration/snippet_compile.rs +0 -95
- data/crates/kobako-wasmtime/tests/integration/support/mod.rs +0 -30
- data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs +0 -86
- data/crates/kobako-wasmtime/tests/integration/unsupported_call.rs +0 -51
- data/ext/kobako/src/runtime/gvl.rs +0 -147
- data/lib/kobako/constant_name.rb +0 -8
- data/sig/kobako/constant_name.rbs +0 -3
- /data/ext/kobako/src/{runtime/pinned_value.rs → pinned_value.rs} +0 -0
|
@@ -0,0 +1,591 @@
|
|
|
1
|
+
//! The Ruby face of the Network: `Kobako::Network`'s functions, which its
|
|
2
|
+
//! values ask where they are written, and a Sandbox's network entries as
|
|
3
|
+
//! contract Grants. Each entry's endpoints are
|
|
4
|
+
//! read from Ruby as an invocation starts, on the guest thread holding the
|
|
5
|
+
//! GVL, so the runtime judges them as data on any thread; its policies are
|
|
6
|
+
//! asked on the guest thread, re-entering Ruby as a mount's block does. A
|
|
7
|
+
//! `Kobako::Network::Builder` only collects what its block declares; the
|
|
8
|
+
//! runtime's `Builder` composes it with the object given beside it.
|
|
9
|
+
|
|
10
|
+
mod mock;
|
|
11
|
+
|
|
12
|
+
use std::sync::Arc;
|
|
13
|
+
|
|
14
|
+
use magnus::value::{Lazy, Opaque, ReprValue};
|
|
15
|
+
use magnus::{
|
|
16
|
+
function, prelude::*, Error as MagnusError, RArray, RClass, RHash, RModule, RString, Ruby,
|
|
17
|
+
Symbol, Value,
|
|
18
|
+
};
|
|
19
|
+
|
|
20
|
+
use kobako_runtime::grant::Grant;
|
|
21
|
+
use kobako_runtime::network::{
|
|
22
|
+
Action, Addresses, Builder, Connection, Credential, CredentialSource, CredentialUnavailable,
|
|
23
|
+
Endpoint, Entry, EntryError, HttpRule, Name, Network, Placement, Policies, Protocol, Request,
|
|
24
|
+
Secret,
|
|
25
|
+
};
|
|
26
|
+
use kobako_runtime::policy::Policy;
|
|
27
|
+
|
|
28
|
+
pub(super) use mock::MockNet;
|
|
29
|
+
|
|
30
|
+
use super::pinned_value::PinnedValue;
|
|
31
|
+
use super::{escape, gvl, name_of, symbol_name_of, value_by_name};
|
|
32
|
+
|
|
33
|
+
/// A Ruby entry as one invocation reads it: its endpoints, its own
|
|
34
|
+
/// `resolve?`, `connect?`, and `request?` for each it plays, and its
|
|
35
|
+
/// credentials.
|
|
36
|
+
struct RubyEntry {
|
|
37
|
+
endpoints: Vec<Endpoint>,
|
|
38
|
+
resolve: Option<Arc<RubyPolicy>>,
|
|
39
|
+
connect: Option<Arc<RubyPolicy>>,
|
|
40
|
+
request: Option<Arc<RubyPolicy>>,
|
|
41
|
+
credentials: Vec<Credential>,
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
impl Entry for RubyEntry {
|
|
45
|
+
fn endpoints(&self) -> Vec<Endpoint> {
|
|
46
|
+
self.endpoints.clone()
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
fn credentials(&self) -> Vec<Credential> {
|
|
50
|
+
self.credentials.clone()
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
fn policies(&self) -> Policies {
|
|
54
|
+
let mut policies = Policies::default();
|
|
55
|
+
if let Some(resolve) = &self.resolve {
|
|
56
|
+
policies = policies.with_resolve_policy(resolve.clone());
|
|
57
|
+
}
|
|
58
|
+
if let Some(connect) = &self.connect {
|
|
59
|
+
policies = policies.with_connect_policy(connect.clone());
|
|
60
|
+
}
|
|
61
|
+
if let Some(request) = &self.request {
|
|
62
|
+
policies = policies.with_request_policy(request.clone());
|
|
63
|
+
}
|
|
64
|
+
policies
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
/// A Ruby object judging one decision when sent `method`: an entry's
|
|
69
|
+
/// `resolve?`, `connect?`, or `request?`, or a policy block's `call`, handed
|
|
70
|
+
/// the name, a `Kobako::Network::Connection`, or a
|
|
71
|
+
/// `Kobako::Network::Request`. A falsy answer or a raised StandardError
|
|
72
|
+
/// refuses, so the guest's call fails and its script goes on; anything else
|
|
73
|
+
/// it raises is held for the host.
|
|
74
|
+
struct RubyPolicy {
|
|
75
|
+
receiver: Opaque<Value>,
|
|
76
|
+
method: &'static str,
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
impl RubyPolicy {
|
|
80
|
+
fn new(receiver: Value, method: &'static str) -> Self {
|
|
81
|
+
Self {
|
|
82
|
+
receiver: Opaque::from(receiver),
|
|
83
|
+
method,
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
fn ask(&self, asked: impl FnOnce(&Ruby) -> Result<Value, MagnusError>) -> bool {
|
|
88
|
+
gvl::reenter(|| {
|
|
89
|
+
let ruby = Ruby::get().expect("Ruby handle unavailable in an entry's policy");
|
|
90
|
+
let receiver: Value = ruby.get_inner(self.receiver);
|
|
91
|
+
asked(&ruby)
|
|
92
|
+
.and_then(|asked| receiver.funcall::<_, _, Value>(self.method, (asked,)))
|
|
93
|
+
.map(|answer| answer.to_bool())
|
|
94
|
+
.unwrap_or_else(|error| {
|
|
95
|
+
let _ = escape::hold(&ruby, error);
|
|
96
|
+
false
|
|
97
|
+
})
|
|
98
|
+
})
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
impl Policy<Name<'_>> for RubyPolicy {
|
|
103
|
+
fn allows(&self, request: &Name<'_>) -> bool {
|
|
104
|
+
self.ask(|ruby| Ok(ruby.str_new(request.name).as_value()))
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
impl Policy<Connection<'_>> for RubyPolicy {
|
|
109
|
+
fn allows(&self, request: &Connection<'_>) -> bool {
|
|
110
|
+
self.ask(|ruby| to_connection(ruby, request))
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
impl Policy<Request<'_>> for RubyPolicy {
|
|
115
|
+
fn allows(&self, request: &Request<'_>) -> bool {
|
|
116
|
+
self.ask(|ruby| to_request(ruby, request))
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
/// A Ruby credential's `value(request)`, asked as a bound request leaves. A
|
|
121
|
+
/// String answers the value and `nil` sends nothing. A raised StandardError
|
|
122
|
+
/// refuses the request, so the guest's call fails and its script goes on;
|
|
123
|
+
/// anything else it raises is held for the host and refuses it too.
|
|
124
|
+
struct RubyCredential {
|
|
125
|
+
credential: Opaque<Value>,
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
impl CredentialSource for RubyCredential {
|
|
129
|
+
fn value_of(&self, request: &Request<'_>) -> Result<Option<Secret>, CredentialUnavailable> {
|
|
130
|
+
gvl::reenter(|| {
|
|
131
|
+
let ruby = Ruby::get().expect("Ruby handle unavailable in a credential's value");
|
|
132
|
+
let credential: Value = ruby.get_inner(self.credential);
|
|
133
|
+
let answer = to_request(&ruby, request).and_then(|request| {
|
|
134
|
+
credential.funcall::<_, _, Option<RString>>("value", (request,))
|
|
135
|
+
});
|
|
136
|
+
answer
|
|
137
|
+
.map(|value| value.map(|value| Secret::new(crate::to_bytes(value))))
|
|
138
|
+
.map_err(|error| {
|
|
139
|
+
let _ = escape::hold(&ruby, error);
|
|
140
|
+
CredentialUnavailable
|
|
141
|
+
})
|
|
142
|
+
})
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
/// Defines `Kobako::Network`, whose values ask these functions where they
|
|
147
|
+
/// are written, so a mistake raises there by the rules an invocation reads
|
|
148
|
+
/// the value with, and a value holds what those rules make of it.
|
|
149
|
+
pub(super) fn register(kobako: RModule) -> Result<(), MagnusError> {
|
|
150
|
+
let network = kobako.define_module("Network")?;
|
|
151
|
+
network.define_singleton_method("normalize_endpoint", function!(normalize_endpoint, 3))?;
|
|
152
|
+
network.define_singleton_method("normalize_rule", function!(normalize_rule, 3))?;
|
|
153
|
+
network.define_singleton_method("normalize_credential", function!(normalize_credential, 2))?;
|
|
154
|
+
network.define_singleton_method("validate_name", function!(validate_name, 1))?;
|
|
155
|
+
mock::register(network)
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
/// The endpoint at `host` and `port` with the `protocol`, `addresses`, and
|
|
159
|
+
/// `rules` `written` of it, as `[host, port, protocol, addresses, rules]`:
|
|
160
|
+
/// each one left out takes the contract's default, and `addresses` and
|
|
161
|
+
/// `rules` stay as written.
|
|
162
|
+
fn normalize_endpoint(
|
|
163
|
+
ruby: &Ruby,
|
|
164
|
+
host: Value,
|
|
165
|
+
port: Value,
|
|
166
|
+
written: RHash,
|
|
167
|
+
) -> Result<(RString, u16, Symbol, RArray, RArray), MagnusError> {
|
|
168
|
+
let [protocol, addresses, rules] =
|
|
169
|
+
["protocol", "addresses", "rules"].map(|name| written.get(ruby.to_symbol(name)));
|
|
170
|
+
let addresses = addresses.map(RArray::try_convert).transpose()?;
|
|
171
|
+
let rules = rules.map(RArray::try_convert).transpose()?;
|
|
172
|
+
let endpoint = build_endpoint(ruby, host, port, protocol, addresses, rules)?;
|
|
173
|
+
let host = ruby.str_new(&endpoint.host);
|
|
174
|
+
host.freeze();
|
|
175
|
+
let addresses = match addresses {
|
|
176
|
+
Some(addresses) => addresses,
|
|
177
|
+
None => {
|
|
178
|
+
let addresses = ruby.ary_new();
|
|
179
|
+
for each in &endpoint.addresses {
|
|
180
|
+
addresses.push(to_addresses_name(ruby, each)?)?;
|
|
181
|
+
}
|
|
182
|
+
addresses.freeze();
|
|
183
|
+
addresses
|
|
184
|
+
}
|
|
185
|
+
};
|
|
186
|
+
let rules = rules.unwrap_or_else(|| {
|
|
187
|
+
let rules = ruby.ary_new();
|
|
188
|
+
rules.freeze();
|
|
189
|
+
rules
|
|
190
|
+
});
|
|
191
|
+
Ok((
|
|
192
|
+
host,
|
|
193
|
+
endpoint.port,
|
|
194
|
+
to_protocol_name(ruby, endpoint.protocol)?,
|
|
195
|
+
addresses,
|
|
196
|
+
rules,
|
|
197
|
+
))
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
/// The rule taking `allow` on `method`, or any when `nil`, on paths `path`
|
|
201
|
+
/// matches, as `[allow, method, path]`.
|
|
202
|
+
fn normalize_rule(
|
|
203
|
+
ruby: &Ruby,
|
|
204
|
+
allow: bool,
|
|
205
|
+
method: Option<Value>,
|
|
206
|
+
path: Value,
|
|
207
|
+
) -> Result<(bool, Option<String>, String), MagnusError> {
|
|
208
|
+
let rule = build_rule(ruby, allow, method, path)?;
|
|
209
|
+
Ok((rule.action == Action::Allow, rule.method, rule.path))
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
/// The rule taking `allow` on `method`, or any when `nil`, on paths `path`
|
|
213
|
+
/// matches, each read as a Symbol or a String.
|
|
214
|
+
fn build_rule(
|
|
215
|
+
ruby: &Ruby,
|
|
216
|
+
allow: bool,
|
|
217
|
+
method: Option<Value>,
|
|
218
|
+
path: Value,
|
|
219
|
+
) -> Result<HttpRule, MagnusError> {
|
|
220
|
+
let method = method
|
|
221
|
+
.map(|method| to_text(ruby, method, "a rule's method"))
|
|
222
|
+
.transpose()?;
|
|
223
|
+
let path = to_text(ruby, path, "a rule's path")?;
|
|
224
|
+
let action = if allow { Action::Allow } else { Action::Deny };
|
|
225
|
+
Ok(HttpRule::new(action, method.as_deref(), path))
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
/// The placeholder text of a credential at `placement`, as
|
|
229
|
+
/// `Kobako::Network::Credential.new` takes them, by the rules an invocation
|
|
230
|
+
/// reads them with.
|
|
231
|
+
fn normalize_credential(
|
|
232
|
+
ruby: &Ruby,
|
|
233
|
+
placement: Value,
|
|
234
|
+
placeholder: Value,
|
|
235
|
+
) -> Result<String, MagnusError> {
|
|
236
|
+
to_placement(ruby, placement)?;
|
|
237
|
+
to_placeholder(ruby, placeholder)
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
/// The text a credential's `placeholder` names.
|
|
241
|
+
fn to_placeholder(ruby: &Ruby, placeholder: Value) -> Result<String, MagnusError> {
|
|
242
|
+
to_text(ruby, placeholder, "a credential's placeholder")
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
/// Refuse an entry's name as `Sandbox#network` takes it, by the rule an
|
|
246
|
+
/// invocation names its Grant with.
|
|
247
|
+
fn validate_name(ruby: &Ruby, name: RString) -> Result<(), MagnusError> {
|
|
248
|
+
Network::new(name.to_string()?, Arc::new(Builder::default()))
|
|
249
|
+
.map(drop)
|
|
250
|
+
.map_err(|err| MagnusError::new(ruby.exception_arg_error(), err.to_string()))
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
/// Each protocol an endpoint speaks beside the Symbol Ruby names it by.
|
|
254
|
+
const PROTOCOL_NAMES: [(Protocol, &str); 3] = [
|
|
255
|
+
(Protocol::Http, "http"),
|
|
256
|
+
(Protocol::Tcp, "tcp"),
|
|
257
|
+
(Protocol::Udp, "udp"),
|
|
258
|
+
];
|
|
259
|
+
|
|
260
|
+
/// Each address set beside the Symbol Ruby names it by.
|
|
261
|
+
const ADDRESS_SET_NAMES: [(Addresses, &str); 3] = [
|
|
262
|
+
(Addresses::Public, "public"),
|
|
263
|
+
(Addresses::Private, "private"),
|
|
264
|
+
(Addresses::Local, "local"),
|
|
265
|
+
];
|
|
266
|
+
|
|
267
|
+
/// `protocol` as the Symbol Ruby names it by.
|
|
268
|
+
fn to_protocol_name(ruby: &Ruby, protocol: Protocol) -> Result<Symbol, MagnusError> {
|
|
269
|
+
name_of(&PROTOCOL_NAMES, &protocol)
|
|
270
|
+
.map(|name| ruby.to_symbol(name))
|
|
271
|
+
.ok_or_else(|| to_unnamed_error(ruby, protocol))
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
/// A contract value the ext gives no Ruby name.
|
|
275
|
+
fn to_unnamed_error(ruby: &Ruby, value: impl std::fmt::Debug) -> MagnusError {
|
|
276
|
+
MagnusError::new(
|
|
277
|
+
ruby.exception_runtime_error(),
|
|
278
|
+
format!("{value:?} has no Ruby name"),
|
|
279
|
+
)
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
/// `addresses` as an endpoint's `addresses` names it: a Symbol for a set,
|
|
283
|
+
/// or a CIDR String.
|
|
284
|
+
fn to_addresses_name(ruby: &Ruby, addresses: &Addresses) -> Result<Value, MagnusError> {
|
|
285
|
+
if let Some(name) = name_of(&ADDRESS_SET_NAMES, addresses) {
|
|
286
|
+
return Ok(ruby.to_symbol(name).as_value());
|
|
287
|
+
}
|
|
288
|
+
match addresses {
|
|
289
|
+
Addresses::Cidr(address, prefix) => {
|
|
290
|
+
Ok(ruby.str_new(&format!("{address}/{prefix}")).as_value())
|
|
291
|
+
}
|
|
292
|
+
other => Err(to_unnamed_error(ruby, other)),
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
/// The text `value` names as `what`: a String, or a Symbol's name, as a
|
|
297
|
+
/// registration's name is taken; another class raises `TypeError`.
|
|
298
|
+
fn to_text(ruby: &Ruby, value: Value, what: &str) -> Result<String, MagnusError> {
|
|
299
|
+
if let Some(name) = symbol_name_of(value)? {
|
|
300
|
+
return Ok(name);
|
|
301
|
+
}
|
|
302
|
+
match RString::from_value(value) {
|
|
303
|
+
Some(text) => text.to_string(),
|
|
304
|
+
None => Err(MagnusError::new(
|
|
305
|
+
ruby.exception_type_error(),
|
|
306
|
+
format!("{what} must be a Symbol or String, got {}", value.class()),
|
|
307
|
+
)),
|
|
308
|
+
}
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
/// The placement a credential's `placement` names: `:bearer`, `:basic`, or
|
|
312
|
+
/// a header's name.
|
|
313
|
+
fn to_placement(ruby: &Ruby, placement: Value) -> Result<Placement, MagnusError> {
|
|
314
|
+
match symbol_name_of(placement)?.as_deref() {
|
|
315
|
+
Some("bearer") => Ok(Placement::Bearer),
|
|
316
|
+
Some("basic") => Ok(Placement::Basic),
|
|
317
|
+
Some(_) => Err(MagnusError::new(
|
|
318
|
+
ruby.exception_arg_error(),
|
|
319
|
+
"a credential's placement must be :bearer, :basic, or a header name",
|
|
320
|
+
)),
|
|
321
|
+
None => Ok(Placement::Header(
|
|
322
|
+
RString::try_convert(placement)?.to_string()?,
|
|
323
|
+
)),
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
/// The credential a Ruby object answering `placement`, `placeholder`, and
|
|
328
|
+
/// `value` stands for, pinned while the guest may ask it for a value.
|
|
329
|
+
fn to_credential(
|
|
330
|
+
ruby: &Ruby,
|
|
331
|
+
credential: Value,
|
|
332
|
+
pins: &mut Vec<PinnedValue>,
|
|
333
|
+
) -> Result<Credential, MagnusError> {
|
|
334
|
+
let placement = to_placement(ruby, credential.funcall("placement", ())?)?;
|
|
335
|
+
let placeholder = to_placeholder(ruby, credential.funcall("placeholder", ())?)?;
|
|
336
|
+
pins.push(PinnedValue::new(ruby, credential));
|
|
337
|
+
let source = Arc::new(RubyCredential {
|
|
338
|
+
credential: Opaque::from(credential),
|
|
339
|
+
});
|
|
340
|
+
Ok(Credential::new(placement, placeholder, source))
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
/// Each element of the Ruby Array `values`, as `convert` reads it.
|
|
344
|
+
fn each_of<T>(
|
|
345
|
+
values: RArray,
|
|
346
|
+
mut convert: impl FnMut(Value) -> Result<T, MagnusError>,
|
|
347
|
+
) -> Result<Vec<T>, MagnusError> {
|
|
348
|
+
(0..values.len() as isize)
|
|
349
|
+
.map(|index| convert(values.entry(index)?))
|
|
350
|
+
.collect()
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
/// `request` as the `Kobako::Network::Request` a Ruby policy reads.
|
|
354
|
+
fn to_request(ruby: &Ruby, request: &Request<'_>) -> Result<Value, MagnusError> {
|
|
355
|
+
let (host, port) = request.authority;
|
|
356
|
+
let names = ruby.ary_from_iter(request.header_names.iter().map(|name| ruby.str_new(name)));
|
|
357
|
+
ruby.get_inner(&REQUEST).funcall(
|
|
358
|
+
"new",
|
|
359
|
+
(
|
|
360
|
+
ruby.ary_from_iter([
|
|
361
|
+
ruby.str_new(host).as_value(),
|
|
362
|
+
ruby.integer_from_i64(i64::from(port)).as_value(),
|
|
363
|
+
]),
|
|
364
|
+
ruby.str_new(request.method),
|
|
365
|
+
ruby.str_new(request.scheme),
|
|
366
|
+
ruby.str_new(request.path),
|
|
367
|
+
names,
|
|
368
|
+
),
|
|
369
|
+
)
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
static REQUEST: Lazy<RClass> =
|
|
373
|
+
Lazy::new(|ruby| crate::constant_by_path(ruby, &["Network", "Request"]));
|
|
374
|
+
|
|
375
|
+
static CONNECTION: Lazy<RClass> =
|
|
376
|
+
Lazy::new(|ruby| crate::constant_by_path(ruby, &["Network", "Connection"]));
|
|
377
|
+
|
|
378
|
+
static BUILDER: Lazy<RClass> =
|
|
379
|
+
Lazy::new(|ruby| crate::constant_by_path(ruby, &["Network", "Builder"]));
|
|
380
|
+
|
|
381
|
+
/// `connection` as the `Kobako::Network::Connection` a Ruby policy reads.
|
|
382
|
+
fn to_connection(ruby: &Ruby, connection: &Connection<'_>) -> Result<Value, MagnusError> {
|
|
383
|
+
let protocol = to_protocol_name(ruby, connection.protocol)?;
|
|
384
|
+
ruby.get_inner(&CONNECTION).funcall(
|
|
385
|
+
"new",
|
|
386
|
+
(ruby.str_new(connection.host), connection.port, protocol),
|
|
387
|
+
)
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
/// One invocation's network Grants, from the Sandbox's entries as
|
|
391
|
+
/// `[name, entry]` pairs, beside the pins keeping each entry playing a policy
|
|
392
|
+
/// in place while the guest may ask it; the caller holds both until the
|
|
393
|
+
/// invocation returns.
|
|
394
|
+
pub(super) fn to_grants(
|
|
395
|
+
ruby: &Ruby,
|
|
396
|
+
entries: RArray,
|
|
397
|
+
) -> Result<(Vec<Grant>, Vec<PinnedValue>), MagnusError> {
|
|
398
|
+
let to_arg_error =
|
|
399
|
+
|err: EntryError| MagnusError::new(ruby.exception_arg_error(), err.to_string());
|
|
400
|
+
let mut grants = Vec::with_capacity(entries.len());
|
|
401
|
+
let mut pins = Vec::new();
|
|
402
|
+
for index in 0..entries.len() as isize {
|
|
403
|
+
let pair: RArray = entries.entry(index)?;
|
|
404
|
+
let name = RString::try_convert(pair.entry(0)?)?.to_string()?;
|
|
405
|
+
let entry = to_entry(ruby, pair.entry(1)?, &mut pins)?;
|
|
406
|
+
grants.push(Grant::Network(
|
|
407
|
+
Network::new(name, entry).map_err(to_arg_error)?,
|
|
408
|
+
));
|
|
409
|
+
}
|
|
410
|
+
Ok((grants, pins))
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
/// The entry a Ruby object stands for. A `Kobako::Network::Builder` is the
|
|
414
|
+
/// object given beside it, then its own endpoints, credentials, and policy
|
|
415
|
+
/// blocks, composed by the runtime's `Builder`; any other object plays the
|
|
416
|
+
/// roles it answers, and one it does not answer has no opinion, so an entry
|
|
417
|
+
/// without endpoints reaches nothing.
|
|
418
|
+
fn to_entry(
|
|
419
|
+
ruby: &Ruby,
|
|
420
|
+
entry: Value,
|
|
421
|
+
pins: &mut Vec<PinnedValue>,
|
|
422
|
+
) -> Result<Arc<dyn Entry>, MagnusError> {
|
|
423
|
+
if !entry.is_kind_of(ruby.get_inner(&BUILDER)) {
|
|
424
|
+
return to_ruby_entry(ruby, entry, pins).map(|entry| Arc::new(entry) as Arc<dyn Entry>);
|
|
425
|
+
}
|
|
426
|
+
let (given, endpoints, credentials, policies): (Value, RArray, RArray, RHash) =
|
|
427
|
+
entry.funcall("to_native", ())?;
|
|
428
|
+
let mut builder = match given.is_nil() {
|
|
429
|
+
true => Builder::default(),
|
|
430
|
+
false => Builder::new(to_entry(ruby, given, pins)?),
|
|
431
|
+
};
|
|
432
|
+
for endpoint in each_of(endpoints, |endpoint| to_endpoint(ruby, endpoint))? {
|
|
433
|
+
builder.endpoint(endpoint);
|
|
434
|
+
}
|
|
435
|
+
for credential in each_of(credentials, |credential| {
|
|
436
|
+
to_credential(ruby, credential, pins)
|
|
437
|
+
})? {
|
|
438
|
+
builder.credential(credential);
|
|
439
|
+
}
|
|
440
|
+
let blocks_of = |hook: &str| -> Result<RArray, MagnusError> {
|
|
441
|
+
RArray::try_convert(policies.aref::<_, Value>(ruby.to_symbol(hook))?)
|
|
442
|
+
};
|
|
443
|
+
for (hook, blocks) in [
|
|
444
|
+
("resolve", blocks_of("resolve")?),
|
|
445
|
+
("connect", blocks_of("connect")?),
|
|
446
|
+
("request", blocks_of("request")?),
|
|
447
|
+
] {
|
|
448
|
+
for block in each_of(blocks, Ok)? {
|
|
449
|
+
pins.push(PinnedValue::new(ruby, block));
|
|
450
|
+
let policy = RubyPolicy::new(block, "call");
|
|
451
|
+
match hook {
|
|
452
|
+
"resolve" => builder.resolve_policy(policy),
|
|
453
|
+
"connect" => builder.connect_policy(policy),
|
|
454
|
+
_ => builder.request_policy(policy),
|
|
455
|
+
};
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
Ok(Arc::new(builder))
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
/// The entry an object other than a Builder stands for, by each role it
|
|
462
|
+
/// answers.
|
|
463
|
+
fn to_ruby_entry(
|
|
464
|
+
ruby: &Ruby,
|
|
465
|
+
entry: Value,
|
|
466
|
+
pins: &mut Vec<PinnedValue>,
|
|
467
|
+
) -> Result<RubyEntry, MagnusError> {
|
|
468
|
+
let answered = |role: &str| -> Result<RArray, MagnusError> {
|
|
469
|
+
match entry.respond_to(role, false)? {
|
|
470
|
+
true => RArray::try_convert(entry.funcall::<_, _, Value>(role, ())?),
|
|
471
|
+
false => Ok(ruby.ary_new()),
|
|
472
|
+
}
|
|
473
|
+
};
|
|
474
|
+
let endpoints = each_of(answered("endpoints")?, |endpoint| {
|
|
475
|
+
to_endpoint(ruby, endpoint)
|
|
476
|
+
})?;
|
|
477
|
+
let credentials = each_of(answered("credentials")?, |credential| {
|
|
478
|
+
to_credential(ruby, credential, pins)
|
|
479
|
+
})?;
|
|
480
|
+
let policy_for = |hook: &'static str| -> Result<Option<Arc<RubyPolicy>>, MagnusError> {
|
|
481
|
+
Ok(entry
|
|
482
|
+
.respond_to(hook, false)?
|
|
483
|
+
.then(|| Arc::new(RubyPolicy::new(entry, hook))))
|
|
484
|
+
};
|
|
485
|
+
let (resolve, connect, request) = (
|
|
486
|
+
policy_for("resolve?")?,
|
|
487
|
+
policy_for("connect?")?,
|
|
488
|
+
policy_for("request?")?,
|
|
489
|
+
);
|
|
490
|
+
if resolve.is_some() || connect.is_some() || request.is_some() {
|
|
491
|
+
pins.push(PinnedValue::new(ruby, entry));
|
|
492
|
+
}
|
|
493
|
+
Ok(RubyEntry {
|
|
494
|
+
endpoints,
|
|
495
|
+
resolve,
|
|
496
|
+
connect,
|
|
497
|
+
request,
|
|
498
|
+
credentials,
|
|
499
|
+
})
|
|
500
|
+
}
|
|
501
|
+
|
|
502
|
+
/// The endpoint a Ruby object answering `host` and `port` stands for, and
|
|
503
|
+
/// `protocol`, `addresses`, and `rules` where it answers them; one it leaves
|
|
504
|
+
/// out takes the contract's default.
|
|
505
|
+
fn to_endpoint(ruby: &Ruby, object: Value) -> Result<Endpoint, MagnusError> {
|
|
506
|
+
let answer = |role: &str| -> Result<Option<Value>, MagnusError> {
|
|
507
|
+
match object.respond_to(role, false)? {
|
|
508
|
+
true => object.funcall(role, ()).map(Some),
|
|
509
|
+
false => Ok(None),
|
|
510
|
+
}
|
|
511
|
+
};
|
|
512
|
+
build_endpoint(
|
|
513
|
+
ruby,
|
|
514
|
+
object.funcall("host", ())?,
|
|
515
|
+
object.funcall("port", ())?,
|
|
516
|
+
answer("protocol")?,
|
|
517
|
+
answer("addresses")?.map(RArray::try_convert).transpose()?,
|
|
518
|
+
answer("rules")?.map(RArray::try_convert).transpose()?,
|
|
519
|
+
)
|
|
520
|
+
}
|
|
521
|
+
|
|
522
|
+
/// The endpoint at `host` and `port`, speaking `protocol`, leading to
|
|
523
|
+
/// `addresses`, and judging by `rules` where each is given, and otherwise
|
|
524
|
+
/// as the contract's `Endpoint::new` makes it.
|
|
525
|
+
fn build_endpoint(
|
|
526
|
+
ruby: &Ruby,
|
|
527
|
+
host: Value,
|
|
528
|
+
port: Value,
|
|
529
|
+
protocol: Option<Value>,
|
|
530
|
+
addresses: Option<RArray>,
|
|
531
|
+
rules: Option<RArray>,
|
|
532
|
+
) -> Result<Endpoint, MagnusError> {
|
|
533
|
+
let to_arg_error = |message: String| MagnusError::new(ruby.exception_arg_error(), message);
|
|
534
|
+
let host = to_text(ruby, host, "an endpoint's host")?;
|
|
535
|
+
let port = i64::try_convert(port)?;
|
|
536
|
+
let port = u16::try_from(port).map_err(|_| {
|
|
537
|
+
to_arg_error(format!(
|
|
538
|
+
"an endpoint's port must be 1 to 65535, got {host}:{port}"
|
|
539
|
+
))
|
|
540
|
+
})?;
|
|
541
|
+
let mut endpoint = Endpoint::new(host, port).map_err(|err| to_arg_error(err.to_string()))?;
|
|
542
|
+
if let Some(protocol) = protocol {
|
|
543
|
+
let protocol = symbol_name_of(protocol)?
|
|
544
|
+
.and_then(|name| value_by_name(&PROTOCOL_NAMES, &name))
|
|
545
|
+
.ok_or_else(|| to_arg_error("protocol must be :http, :tcp, or :udp".to_string()))?;
|
|
546
|
+
endpoint = endpoint.with_protocol(protocol);
|
|
547
|
+
}
|
|
548
|
+
if let Some(addresses) = addresses {
|
|
549
|
+
let addresses = each_of(addresses, |address| {
|
|
550
|
+
to_addresses(address).ok_or_else(|| {
|
|
551
|
+
to_arg_error(
|
|
552
|
+
"addresses must be :public, :private, :local, a CIDR, or an IPAddr".to_string(),
|
|
553
|
+
)
|
|
554
|
+
})
|
|
555
|
+
})?;
|
|
556
|
+
endpoint = endpoint.with_addresses(addresses);
|
|
557
|
+
}
|
|
558
|
+
if let Some(rules) = rules {
|
|
559
|
+
endpoint = endpoint.with_rules(each_of(rules, |rule| to_rule(ruby, rule))?);
|
|
560
|
+
}
|
|
561
|
+
Ok(endpoint)
|
|
562
|
+
}
|
|
563
|
+
|
|
564
|
+
/// The rule a Ruby object answering `allow?`, `method`, and `path` stands for.
|
|
565
|
+
fn to_rule(ruby: &Ruby, rule: Value) -> Result<HttpRule, MagnusError> {
|
|
566
|
+
build_rule(
|
|
567
|
+
ruby,
|
|
568
|
+
rule.funcall::<_, _, Value>("allow?", ())?.to_bool(),
|
|
569
|
+
rule.funcall("method", ())?,
|
|
570
|
+
rule.funcall("path", ())?,
|
|
571
|
+
)
|
|
572
|
+
}
|
|
573
|
+
|
|
574
|
+
/// An address set's symbol, a CIDR as `address/prefix`, or an `IPAddr`, which
|
|
575
|
+
/// carries its prefix apart from its address; the runtime reads the CIDR as
|
|
576
|
+
/// it reads an endpoint's host.
|
|
577
|
+
fn to_addresses(value: Value) -> Option<Addresses> {
|
|
578
|
+
if let Some(name) = symbol_name_of(value).ok()? {
|
|
579
|
+
return value_by_name(&ADDRESS_SET_NAMES, &name);
|
|
580
|
+
}
|
|
581
|
+
let cidr = match RString::try_convert(value) {
|
|
582
|
+
Ok(text) => text.to_string().ok()?,
|
|
583
|
+
Err(_) if value.respond_to("prefix", false).ok()? => {
|
|
584
|
+
let address: String = value.funcall("to_s", ()).ok()?;
|
|
585
|
+
let prefix: u8 = value.funcall("prefix", ()).ok()?;
|
|
586
|
+
format!("{address}/{prefix}")
|
|
587
|
+
}
|
|
588
|
+
Err(_) => return None,
|
|
589
|
+
};
|
|
590
|
+
Addresses::from_cidr(&cidr)
|
|
591
|
+
}
|