Git-Mirrors/veilid
1
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2024-10-01 01:26:08 -04:00
Code Issues Packages Projects Releases Wiki Activity

clippy work

Browse Source
This commit is contained in:
Christien Rioux 2023-09-17 19:37:02 -04:00
parent 8a1260ed48
commit 6438a64fc7
62 changed files with 414 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
veilid-cli/src/main.rs
View File

@ -1,4 +1,5 @@
#![deny(clippy::all)] #![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)] #![deny(unused_must_use)]
#![recursion_limit = "256"] #![recursion_limit = "256"]

8
veilid-cli/src/ui.rs
View File

@ -482,7 +482,9 @@ impl UI {
) )
.as_bytes(), .as_bytes(),
) )
.is_ok() && std::io::stdout().flush().is_ok() { .is_ok()
&& std::io::stdout().flush().is_ok()
{
let color = *Self::inner_mut(s).log_colors.get(&Level::Info).unwrap(); let color = *Self::inner_mut(s).log_colors.get(&Level::Info).unwrap();
cursive_flexi_logger_view::parse_lines_to_log( cursive_flexi_logger_view::parse_lines_to_log(
color.into(), color.into(),
@ -938,10 +940,12 @@ impl UI {
// } // }
} }
type CallbackSink = Box<dyn FnOnce(&mut Cursive) + 'static + Send>;
#[derive(Clone)] #[derive(Clone)]
pub struct UISender { pub struct UISender {
inner: Arc<Mutex<UIInner>>, inner: Arc<Mutex<UIInner>>,
cb_sink: Sender<Box<dyn FnOnce(&mut Cursive) + 'static + Send>>, cb_sink: Sender<CallbackSink>,
} }
impl UISender { impl UISender {

36
veilid-core/build.rs
View File

@ -18,8 +18,7 @@ fn get_desired_capnp_version_string() -> String {
let capnp_path = search_file(env!("CARGO_MANIFEST_DIR"), ".capnp_version") let capnp_path = search_file(env!("CARGO_MANIFEST_DIR"), ".capnp_version")
.expect("should find .capnp_version file"); .expect("should find .capnp_version file");
std::fs::read_to_string(&capnp_path) std::fs::read_to_string(&capnp_path)
.unwrap_or_else(|_| panic!("can't read .capnp_version file here: {:?}", .unwrap_or_else(|_| panic!("can't read .capnp_version file here: {:?}", capnp_path))
capnp_path))
.trim() .trim()
.to_owned() .to_owned()
} }
@ -45,8 +44,7 @@ fn get_desired_protoc_version_string() -> String {
let protoc_path = search_file(env!("CARGO_MANIFEST_DIR"), ".protoc_version") let protoc_path = search_file(env!("CARGO_MANIFEST_DIR"), ".protoc_version")
.expect("should find .protoc_version file"); .expect("should find .protoc_version file");
std::fs::read_to_string(&protoc_path) std::fs::read_to_string(&protoc_path)
.unwrap_or_else(|_| panic!("can't read .protoc_version file here: {:?}", .unwrap_or_else(|_| panic!("can't read .protoc_version file here: {:?}", protoc_path))
protoc_path))
.trim() .trim()
.to_owned() .to_owned()
} }
@ -75,11 +73,18 @@ fn main() {
let protoc_version_string = get_protoc_version_string(); let protoc_version_string = get_protoc_version_string();
// Check capnp version // Check capnp version
let desired_capnp_major_version = let desired_capnp_major_version = desired_capnp_version_string
usize::from_str_radix(desired_capnp_version_string.split_once('.').unwrap().0, 10) .split_once('.')
.expect("should be valid int"); .unwrap()
.0
.parse::<usize>()
.expect("should be valid int");
if usize::from_str_radix(capnp_version_string.split_once('.').unwrap().0, 10) if capnp_version_string
.split_once('.')
.unwrap()
.0
.parse::<usize>()
.expect("should be valid int") .expect("should be valid int")
!= desired_capnp_major_version != desired_capnp_major_version
{ {
@ -95,10 +100,17 @@ fn main() {
} }
// Check protoc version // Check protoc version
let desired_protoc_major_version = let desired_protoc_major_version = desired_protoc_version_string
usize::from_str_radix(desired_protoc_version_string.split_once('.').unwrap().0, 10) .split_once('.')
.expect("should be valid int"); .unwrap()
if usize::from_str_radix(protoc_version_string.split_once('.').unwrap().0, 10) .0
.parse::<usize>()
.expect("should be valid int");
if protoc_version_string
.split_once('.')
.unwrap()
.0
.parse::<usize>()
.expect("should be valid int") .expect("should be valid int")
< desired_protoc_major_version < desired_protoc_major_version
{ {

2
veilid-core/src/crypto/envelope.rs
View File

@ -236,7 +236,7 @@ impl Envelope {
} }
// Compress body // Compress body
let body = compress_prepend_size(&body); let body = compress_prepend_size(body);
// Ensure body isn't too long // Ensure body isn't too long
let envelope_size: usize = body.len() + MIN_ENVELOPE_SIZE; let envelope_size: usize = body.len() + MIN_ENVELOPE_SIZE;

6
veilid-core/src/crypto/tests/mod.rs
View File

@ -8,10 +8,10 @@ use crate::tests::common::test_veilid_config::*;
async fn crypto_tests_startup() -> VeilidAPI { async fn crypto_tests_startup() -> VeilidAPI {
trace!("crypto_tests: starting"); trace!("crypto_tests: starting");
let (update_callback, config_callback) = setup_veilid_core(); let (update_callback, config_callback) = setup_veilid_core();
let api = api_startup(update_callback, config_callback)
api_startup(update_callback, config_callback)
.await .await
.expect("startup failed"); .expect("startup failed")
api
} }
async fn crypto_tests_shutdown(api: VeilidAPI) { async fn crypto_tests_shutdown(api: VeilidAPI) {

12
veilid-core/src/crypto/tests/test_types.rs
View File

@ -228,7 +228,7 @@ pub async fn test_encode_decode(vcrypto: CryptoSystemVersion) {
pub async fn test_typed_convert(vcrypto: CryptoSystemVersion) { pub async fn test_typed_convert(vcrypto: CryptoSystemVersion) {
let tks1 = format!( let tks1 = format!(
"{}:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ", "{}:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ",
vcrypto.kind().to_string() vcrypto.kind()
); );
let tk1 = TypedKey::from_str(&tks1).expect("failed"); let tk1 = TypedKey::from_str(&tks1).expect("failed");
let tks1x = tk1.to_string(); let tks1x = tk1.to_string();
@ -236,22 +236,22 @@ pub async fn test_typed_convert(vcrypto: CryptoSystemVersion) {
let tks2 = format!( let tks2 = format!(
"{}:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzd", "{}:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzd",
vcrypto.kind().to_string() vcrypto.kind()
); );
let _tk2 = TypedKey::from_str(&tks2).expect_err("succeeded when it shouldnt have"); let _tk2 = TypedKey::from_str(&tks2).expect_err("succeeded when it shouldnt have");
let tks3 = format!("XXXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ",); let tks3 = "XXXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ".to_string();
let tk3 = TypedKey::from_str(&tks3).expect("failed"); let tk3 = TypedKey::from_str(&tks3).expect("failed");
let tks3x = tk3.to_string(); let tks3x = tk3.to_string();
assert_eq!(tks3, tks3x); assert_eq!(tks3, tks3x);
let tks4 = format!("XXXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzd",); let tks4 = "XXXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzd".to_string();
let _tk4 = TypedKey::from_str(&tks4).expect_err("succeeded when it shouldnt have"); let _tk4 = TypedKey::from_str(&tks4).expect_err("succeeded when it shouldnt have");
let tks5 = format!("XXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ",); let tks5 = "XXX:7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ".to_string();
let _tk5 = TypedKey::from_str(&tks5).expect_err("succeeded when it shouldnt have"); let _tk5 = TypedKey::from_str(&tks5).expect_err("succeeded when it shouldnt have");
let tks6 = format!("7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ",); let tks6 = "7lxDEabK_qgjbe38RtBa3IZLrud84P6NhGP-pRTZzdQ".to_string();
let tk6 = TypedKey::from_str(&tks6).expect("failed"); let tk6 = TypedKey::from_str(&tks6).expect("failed");
let tks6x = tk6.to_string(); let tks6x = tk6.to_string();
assert!(tks6x.ends_with(&tks6)); assert!(tks6x.ends_with(&tks6));

28
veilid-core/src/crypto/types/byte_array_types.rs
View File

@ -77,7 +77,7 @@ where
macro_rules! byte_array_type { macro_rules! byte_array_type {
($name:ident, $size:expr, $encoded_size:expr) => { ($name:ident, $size:expr, $encoded_size:expr) => {
#[derive(Clone, Copy, Hash)] #[derive(Clone, Copy, Hash, PartialOrd, Ord, PartialEq, Eq)]
#[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))] #[cfg_attr(target_arch = "wasm32", derive(Tsify), tsify(into_wasm_abi))]
pub struct $name { pub struct $name {
pub bytes: [u8; $size], pub bytes: [u8; $size],
@ -114,32 +114,6 @@ macro_rules! byte_array_type {
} }
} }
impl PartialOrd for $name {
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for $name {
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
for n in 0..$size {
let c = self.bytes[n].cmp(&other.bytes[n]);
if c != core::cmp::Ordering::Equal {
return c;
}
}
core::cmp::Ordering::Equal
}
}
impl PartialEq for $name {
fn eq(&self, other: &Self) -> bool {
self.bytes == other.bytes
}
}
impl Eq for $name {}
impl $name { impl $name {
pub fn new(bytes: [u8; $size]) -> Self { pub fn new(bytes: [u8; $size]) -> Self {
Self { bytes } Self { bytes }

25
veilid-core/src/crypto/types/crypto_typed_group.rs
View File

@ -93,16 +93,13 @@ where
} }
/// Return preferred typed key of our supported crypto kinds /// Return preferred typed key of our supported crypto kinds
pub fn best(&self) -> Option<CryptoTyped<K>> { pub fn best(&self) -> Option<CryptoTyped<K>> {
match self.items.first().copied() { self.items
None => None, .first()
Some(k) => { .copied()
if !VALID_CRYPTO_KINDS.contains(&k.kind) { .filter(|k| VALID_CRYPTO_KINDS.contains(&k.kind))
None }
} else { pub fn is_empty(&self) -> bool {
Some(k) self.items.is_empty()
}
}
}
} }
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.items.len() self.items.len()
@ -204,7 +201,7 @@ where
if &s[0..1] != "[" || &s[(s.len() - 1)..] != "]" { if &s[0..1] != "[" || &s[(s.len() - 1)..] != "]" {
apibail_parse_error!("invalid format", s); apibail_parse_error!("invalid format", s);
} }
for x in s[1..s.len() - 1].split(",") { for x in s[1..s.len() - 1].split(',') {
let tk = CryptoTyped::<K>::from_str(x.trim())?; let tk = CryptoTyped::<K>::from_str(x.trim())?;
items.push(tk); items.push(tk);
} }
@ -272,7 +269,7 @@ where
tks tks
} }
} }
impl<K> Into<Vec<CryptoTyped<K>>> for CryptoTypedGroup<K> impl<K> From<CryptoTypedGroup<K>> for Vec<CryptoTyped<K>>
where where
K: Clone K: Clone
+ Copy + Copy
@ -286,7 +283,7 @@ where
+ Hash + Hash
+ Encodable, + Encodable,
{ {
fn into(self) -> Vec<CryptoTyped<K>> { fn from(val: CryptoTypedGroup<K>) -> Self {
self.items val.items
} }
} }

2
veilid-core/src/crypto/types/keypair.rs
View File

@ -96,7 +96,7 @@ impl<'de> serde::Deserialize<'de> for KeyPair {
D: serde::Deserializer<'de>, D: serde::Deserializer<'de>,
{ {
let s = <String as serde::Deserialize>::deserialize(deserializer)?; let s = <String as serde::Deserialize>::deserialize(deserializer)?;
if s == "" { if s.is_empty() {
return Ok(KeyPair::default()); return Ok(KeyPair::default());
} }
KeyPair::try_decode(s.as_str()).map_err(serde::de::Error::custom) KeyPair::try_decode(s.as_str()).map_err(serde::de::Error::custom)

10
veilid-core/src/crypto/vld0/mod.rs
View File

@ -134,8 +134,8 @@ impl CryptoSystem for CryptoSystemVLD0 {
SharedSecret::new(s) SharedSecret::new(s)
} }
fn compute_dh(&self, key: &PublicKey, secret: &SecretKey) -> VeilidAPIResult<SharedSecret> { fn compute_dh(&self, key: &PublicKey, secret: &SecretKey) -> VeilidAPIResult<SharedSecret> {
let pk_xd = public_to_x25519_pk(&key)?; let pk_xd = public_to_x25519_pk(key)?;
let sk_xd = secret_to_x25519_sk(&secret)?; let sk_xd = secret_to_x25519_sk(secret)?;
let dh_bytes = sk_xd.diffie_hellman(&pk_xd).to_bytes(); let dh_bytes = sk_xd.diffie_hellman(&pk_xd).to_bytes();
@ -188,9 +188,9 @@ impl CryptoSystem for CryptoSystemVLD0 {
fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> CryptoKeyDistance { fn distance(&self, key1: &PublicKey, key2: &PublicKey) -> CryptoKeyDistance {
let mut bytes = [0u8; CRYPTO_KEY_LENGTH]; let mut bytes = [0u8; CRYPTO_KEY_LENGTH];
for n in 0..CRYPTO_KEY_LENGTH { (0..CRYPTO_KEY_LENGTH).for_each(|n| {
bytes[n] = key1.bytes[n] ^ key2.bytes[n]; bytes[n] = key1.bytes[n] ^ key2.bytes[n];
} });
CryptoKeyDistance::new(bytes) CryptoKeyDistance::new(bytes)
} }
@ -219,7 +219,7 @@ impl CryptoSystem for CryptoSystemVLD0 {
let sig = Signature::new(sig_bytes.to_bytes()); let sig = Signature::new(sig_bytes.to_bytes());
self.verify(dht_key, &data, &sig)?; self.verify(dht_key, data, &sig)?;
Ok(sig) Ok(sig)
} }

2
veilid-core/src/intf/mod.rs
View File

@ -9,4 +9,4 @@ mod native;
#[cfg(not(target_arch = "wasm32"))] #[cfg(not(target_arch = "wasm32"))]
pub use native::*; pub use native::*;
pub static KNOWN_PROTECTED_STORE_KEYS: [&'static str; 2] = ["device_encryption_key", "_test_key"]; pub static KNOWN_PROTECTED_STORE_KEYS: [&str; 2] = ["device_encryption_key", "_test_key"];

6
veilid-core/src/intf/native/network_interfaces/apple.rs
View File

@ -324,7 +324,7 @@ impl PlatformSupportApple {
let intf_index = unsafe { (*rt).rtm_index } as u32; let intf_index = unsafe { (*rt).rtm_index } as u32;
// Fill in sockaddr table // Fill in sockaddr table
for i in 0..(RTAX_MAX as usize) { (0..(RTAX_MAX as usize)).for_each(|i| {
if rtm_addrs & (1 << i) != 0 { if rtm_addrs & (1 << i) != 0 {
sa_tab[i] = sa; sa_tab[i] = sa;
sa = unsafe { sa = unsafe {
@ -333,7 +333,7 @@ impl PlatformSupportApple {
sa sa
}; };
} }
} });
// Look for gateways // Look for gateways
if rtm_addrs & (RTA_DST | RTA_GATEWAY) == (RTA_DST | RTA_GATEWAY) { if rtm_addrs & (RTA_DST | RTA_GATEWAY) == (RTA_DST | RTA_GATEWAY) {
@ -373,7 +373,7 @@ impl PlatformSupportApple {
} }
fn get_address_flags(ifname: &str, addr: sockaddr_in6) -> EyreResult<AddressFlags> { fn get_address_flags(ifname: &str, addr: sockaddr_in6) -> EyreResult<AddressFlags> {
let mut req = in6_ifreq::from_name(&ifname).unwrap(); let mut req = in6_ifreq::from_name(ifname).unwrap();
req.set_addr(addr); req.set_addr(addr);
let sock = unsafe { socket(AF_INET6, SOCK_DGRAM, 0) }; let sock = unsafe { socket(AF_INET6, SOCK_DGRAM, 0) };

2
veilid-core/src/intf/native/network_interfaces/mod.rs
View File

@ -359,7 +359,7 @@ impl NetworkInterfaces {
let old_best_addresses = inner.interface_address_cache.clone(); let old_best_addresses = inner.interface_address_cache.clone();
// redo the address cache // redo the address cache
Self::cache_best_addresses(&mut *inner); Self::cache_best_addresses(&mut inner);
// See if our best addresses have changed // See if our best addresses have changed
if old_best_addresses != inner.interface_address_cache { if old_best_addresses != inner.interface_address_cache {

1
veilid-core/src/lib.rs
View File

@ -22,6 +22,7 @@
//! //!
#![deny(clippy::all)] #![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)] #![deny(unused_must_use)]
#![recursion_limit = "256"] #![recursion_limit = "256"]

12
veilid-core/src/network_manager/address_filter.rs
View File

@ -244,12 +244,12 @@ impl AddressFilter {
self.unlocked_inner.max_connections_per_ip6_prefix_size, self.unlocked_inner.max_connections_per_ip6_prefix_size,
addr, addr,
); );
self.is_ip_addr_punished_inner(&*inner, ipblock) self.is_ip_addr_punished_inner(&inner, ipblock)
} }
pub fn get_dial_info_failed_ts(&self, dial_info: &DialInfo) -> Option<Timestamp> { pub fn get_dial_info_failed_ts(&self, dial_info: &DialInfo) -> Option<Timestamp> {
let inner = self.inner.lock(); let inner = self.inner.lock();
self.get_dial_info_failed_ts_inner(&*inner, dial_info) self.get_dial_info_failed_ts_inner(&inner, dial_info)
} }
pub fn set_dial_info_failed(&self, dial_info: DialInfo) { pub fn set_dial_info_failed(&self, dial_info: DialInfo) {
@ -301,7 +301,7 @@ impl AddressFilter {
pub fn is_node_id_punished(&self, node_id: TypedKey) -> bool { pub fn is_node_id_punished(&self, node_id: TypedKey) -> bool {
let inner = self.inner.lock(); let inner = self.inner.lock();
self.is_node_id_punished_inner(&*inner, node_id) self.is_node_id_punished_inner(&inner, node_id)
} }
pub fn punish_node_id(&self, node_id: TypedKey) { pub fn punish_node_id(&self, node_id: TypedKey) {
@ -333,8 +333,8 @@ impl AddressFilter {
) -> EyreResult<()> { ) -> EyreResult<()> {
// //
let mut inner = self.inner.lock(); let mut inner = self.inner.lock();
self.purge_old_timestamps(&mut *inner, cur_ts); self.purge_old_timestamps(&mut inner, cur_ts);
self.purge_old_punishments(&mut *inner, cur_ts); self.purge_old_punishments(&mut inner, cur_ts);
Ok(()) Ok(())
} }
@ -411,7 +411,7 @@ impl AddressFilter {
); );
let ts = get_aligned_timestamp(); let ts = get_aligned_timestamp();
self.purge_old_timestamps(&mut *inner, ts); self.purge_old_timestamps(&mut inner, ts);
match ipblock { match ipblock {
IpAddr::V4(v4) => { IpAddr::V4(v4) => {

2
veilid-core/src/network_manager/connection_handle.rs
View File

@ -31,7 +31,7 @@ impl ConnectionHandle {
} }
pub fn connection_descriptor(&self) -> ConnectionDescriptor { pub fn connection_descriptor(&self) -> ConnectionDescriptor {
self.descriptor.clone() self.descriptor
} }
#[cfg_attr(feature="verbose-tracing", instrument(level="trace", skip(self, message), fields(message.len = message.len())))] #[cfg_attr(feature="verbose-tracing", instrument(level="trace", skip(self, message), fields(message.len = message.len())))]

7
veilid-core/src/network_manager/connection_manager.rs
View File

@ -117,13 +117,12 @@ impl ConnectionManager {
// Remove the inner from the lock // Remove the inner from the lock
let mut inner = { let mut inner = {
let mut inner_lock = self.arc.inner.lock(); let mut inner_lock = self.arc.inner.lock();
let inner = match inner_lock.take() { match inner_lock.take() {
Some(v) => v, Some(v) => v,
None => { None => {
panic!("not started"); panic!("not started");
} }
}; }
inner
}; };
// Stop all the connections and the async processor // Stop all the connections and the async processor
@ -251,7 +250,7 @@ impl ConnectionManager {
dial_info: DialInfo, dial_info: DialInfo,
) -> EyreResult<NetworkResult<ConnectionHandle>> { ) -> EyreResult<NetworkResult<ConnectionHandle>> {
let peer_address = dial_info.to_peer_address(); let peer_address = dial_info.to_peer_address();
let remote_addr = peer_address.to_socket_addr(); let remote_addr = peer_address.socket_addr();
let mut preferred_local_address = self let mut preferred_local_address = self
.network_manager() .network_manager()
.net() .net()

20
veilid-core/src/network_manager/connection_table.rs
View File

@ -164,7 +164,7 @@ impl ConnectionTable {
} }
// Filter by ip for connection limits // Filter by ip for connection limits
let ip_addr = descriptor.remote_address().to_ip_addr(); let ip_addr = descriptor.remote_address().ip_addr();
match inner.address_filter.add_connection(ip_addr) { match inner.address_filter.add_connection(ip_addr) {
Ok(()) => {} Ok(()) => {}
Err(e) => { Err(e) => {
@ -196,7 +196,7 @@ impl ConnectionTable {
} }
log_net!(debug "== LRU Connection Killed: {} -> {}", lruk, lru_conn.debug_print(get_aligned_timestamp())); log_net!(debug "== LRU Connection Killed: {} -> {}", lruk, lru_conn.debug_print(get_aligned_timestamp()));
out_conn = Some(Self::remove_connection_records(&mut *inner, lruk)); out_conn = Some(Self::remove_connection_records(&mut inner, lruk));
break; break;
} }
} }
@ -237,11 +237,11 @@ impl ConnectionTable {
best_port: Option<u16>, best_port: Option<u16>,
remote: PeerAddress, remote: PeerAddress,
) -> Option<ConnectionHandle> { ) -> Option<ConnectionHandle> {
let mut inner = self.inner.lock(); let inner = &mut *self.inner.lock();
let all_ids_by_remote = inner.ids_by_remote.get(&remote)?; let all_ids_by_remote = inner.ids_by_remote.get(&remote)?;
let protocol_index = Self::protocol_to_index(remote.protocol_type()); let protocol_index = Self::protocol_to_index(remote.protocol_type());
if all_ids_by_remote.len() == 0 { if all_ids_by_remote.is_empty() {
// no connections // no connections
return None; return None;
} }
@ -253,11 +253,11 @@ impl ConnectionTable {
} }
// multiple connections, find the one that matches the best port, or the most recent // multiple connections, find the one that matches the best port, or the most recent
if let Some(best_port) = best_port { if let Some(best_port) = best_port {
for id in all_ids_by_remote.iter().copied() { for id in all_ids_by_remote {
let nc = inner.conn_by_id[protocol_index].peek(&id).unwrap(); let nc = inner.conn_by_id[protocol_index].peek(id).unwrap();
if let Some(local_addr) = nc.connection_descriptor().local() { if let Some(local_addr) = nc.connection_descriptor().local() {
if local_addr.port() == best_port { if local_addr.port() == best_port {
let nc = inner.conn_by_id[protocol_index].get(&id).unwrap(); let nc = inner.conn_by_id[protocol_index].get(id).unwrap();
return Some(nc.get_handle()); return Some(nc.get_handle());
} }
} }
@ -331,7 +331,7 @@ impl ConnectionTable {
} }
} }
// address_filter // address_filter
let ip_addr = remote.to_socket_addr().ip(); let ip_addr = remote.socket_addr().ip();
inner inner
.address_filter .address_filter
.remove_connection(ip_addr) .remove_connection(ip_addr)
@ -347,7 +347,7 @@ impl ConnectionTable {
if !inner.conn_by_id[protocol_index].contains_key(&id) { if !inner.conn_by_id[protocol_index].contains_key(&id) {
return None; return None;
} }
let conn = Self::remove_connection_records(&mut *inner, id); let conn = Self::remove_connection_records(&mut inner, id);
Some(conn) Some(conn)
} }
@ -358,7 +358,7 @@ impl ConnectionTable {
for t in 0..inner.conn_by_id.len() { for t in 0..inner.conn_by_id.len() {
out += &format!( out += &format!(
" {} Connections: ({}/{})\n", " {} Connections: ({}/{})\n",
Self::index_to_protocol(t).to_string(), Self::index_to_protocol(t),
inner.conn_by_id[t].len(), inner.conn_by_id[t].len(),
inner.max_connections[t] inner.max_connections[t]
); );

8
veilid-core/src/network_manager/mod.rs
View File

@ -61,7 +61,7 @@ pub const PUBLIC_ADDRESS_CHECK_TASK_INTERVAL_SECS: u32 = 60;
pub const PUBLIC_ADDRESS_INCONSISTENCY_TIMEOUT_US: TimestampDuration = pub const PUBLIC_ADDRESS_INCONSISTENCY_TIMEOUT_US: TimestampDuration =
TimestampDuration::new(300_000_000u64); // 5 minutes TimestampDuration::new(300_000_000u64); // 5 minutes
pub const PUBLIC_ADDRESS_INCONSISTENCY_PUNISHMENT_TIMEOUT_US: TimestampDuration = pub const PUBLIC_ADDRESS_INCONSISTENCY_PUNISHMENT_TIMEOUT_US: TimestampDuration =
TimestampDuration::new(3600_000_000u64); // 60 minutes TimestampDuration::new(3_600_000_000_u64); // 60 minutes
pub const ADDRESS_FILTER_TASK_INTERVAL_SECS: u32 = 60; pub const ADDRESS_FILTER_TASK_INTERVAL_SECS: u32 = 60;
pub const BOOT_MAGIC: &[u8; 4] = b"BOOT"; pub const BOOT_MAGIC: &[u8; 4] = b"BOOT";
@ -261,7 +261,7 @@ impl NetworkManager {
where where
F: FnOnce(&VeilidConfigInner) -> R, F: FnOnce(&VeilidConfigInner) -> R,
{ {
f(&*self.unlocked_inner.config.get()) f(&self.unlocked_inner.config.get())
} }
pub fn storage_manager(&self) -> StorageManager { pub fn storage_manager(&self) -> StorageManager {
self.unlocked_inner.storage_manager.clone() self.unlocked_inner.storage_manager.clone()
@ -892,7 +892,7 @@ impl NetworkManager {
data.len(), data.len(),
connection_descriptor connection_descriptor
); );
let remote_addr = connection_descriptor.remote_address().to_ip_addr(); let remote_addr = connection_descriptor.remote_address().ip_addr();
// Network accounting // Network accounting
self.stats_packet_rcvd(remote_addr, ByteCount::new(data.len() as u64)); self.stats_packet_rcvd(remote_addr, ByteCount::new(data.len() as u64));
@ -900,7 +900,7 @@ impl NetworkManager {
// If this is a zero length packet, just drop it, because these are used for hole punching // If this is a zero length packet, just drop it, because these are used for hole punching
// and possibly other low-level network connectivity tasks and will never require // and possibly other low-level network connectivity tasks and will never require
// more processing or forwarding // more processing or forwarding
if data.len() == 0 { if data.is_empty() {
return Ok(true); return Ok(true);
} }

29
veilid-core/src/network_manager/native/discovery_context.rs
View File

@ -141,10 +141,8 @@ impl DiscoveryContext {
let dial_info_filter = DialInfoFilter::all() let dial_info_filter = DialInfoFilter::all()
.with_protocol_type(protocol_type) .with_protocol_type(protocol_type)
.with_address_type(address_type); .with_address_type(address_type);
let inbound_dial_info_entry_filter = RoutingTable::make_inbound_dial_info_entry_filter( let inbound_dial_info_entry_filter =
routing_domain, RoutingTable::make_inbound_dial_info_entry_filter(routing_domain, dial_info_filter);
dial_info_filter.clone(),
);
let disallow_relays_filter = Box::new( let disallow_relays_filter = Box::new(
move |rti: &RoutingTableInner, v: Option<Arc<BucketEntry>>| { move |rti: &RoutingTableInner, v: Option<Arc<BucketEntry>>| {
let v = v.unwrap(); let v = v.unwrap();
@ -199,7 +197,7 @@ impl DiscoveryContext {
let node = node.filtered_clone( let node = node.filtered_clone(
NodeRefFilter::new() NodeRefFilter::new()
.with_routing_domain(routing_domain) .with_routing_domain(routing_domain)
.with_dial_info_filter(dial_info_filter.clone()), .with_dial_info_filter(dial_info_filter),
); );
async move { async move {
if let Some(address) = this.request_public_address(node.clone()).await { if let Some(address) = this.request_public_address(node.clone()).await {
@ -219,9 +217,7 @@ impl DiscoveryContext {
let mut external_address_infos = Vec::new(); let mut external_address_infos = Vec::new();
for ni in 0..nodes.len() - 1 { for node in nodes.iter().take(nodes.len() - 1).cloned() {
let node = nodes[ni].clone();
let gpa_future = get_public_address_func(node); let gpa_future = get_public_address_func(node);
unord.push(gpa_future); unord.push(gpa_future);
@ -277,15 +273,15 @@ impl DiscoveryContext {
node_ref.set_filter(None); node_ref.set_filter(None);
// ask the node to send us a dial info validation receipt // ask the node to send us a dial info validation receipt
let out = rpc_processor
rpc_processor
.rpc_call_validate_dial_info(node_ref.clone(), dial_info, redirect) .rpc_call_validate_dial_info(node_ref.clone(), dial_info, redirect)
.await .await
.map_err(logthru_net!( .map_err(logthru_net!(
"failed to send validate_dial_info to {:?}", "failed to send validate_dial_info to {:?}",
node_ref node_ref
)) ))
.unwrap_or(false); .unwrap_or(false)
out
} }
#[instrument(level = "trace", skip(self), ret)] #[instrument(level = "trace", skip(self), ret)]
@ -307,9 +303,14 @@ impl DiscoveryContext {
// Attempt a port mapping. If this doesn't succeed, it's not going to // Attempt a port mapping. If this doesn't succeed, it's not going to
let Some(mapped_external_address) = igd_manager let Some(mapped_external_address) = igd_manager
.map_any_port(low_level_protocol_type, address_type, local_port, Some(external_1.address.to_ip_addr())) .map_any_port(
.await else low_level_protocol_type,
{ address_type,
local_port,
Some(external_1.address.ip_addr()),
)
.await
else {
return None; return None;
}; };

24
veilid-core/src/network_manager/native/igd_manager.rs
View File

@ -184,7 +184,7 @@ impl IGDManager {
let mut found = None; let mut found = None;
for (pmk, pmv) in &inner.port_maps { for (pmk, pmv) in &inner.port_maps {
if pmk.llpt == llpt && pmk.at == at && pmv.mapped_port == mapped_port { if pmk.llpt == llpt && pmk.at == at && pmv.mapped_port == mapped_port {
found = Some(pmk.clone()); found = Some(*pmk);
break; break;
} }
} }
@ -192,7 +192,7 @@ impl IGDManager {
let _pmv = inner.port_maps.remove(&pmk).expect("key found but remove failed"); let _pmv = inner.port_maps.remove(&pmk).expect("key found but remove failed");
// Find gateway // Find gateway
let gw = Self::find_gateway(&mut *inner, at)?; let gw = Self::find_gateway(&mut inner, at)?;
// Unmap port // Unmap port
match gw.remove_port(convert_llpt(llpt), mapped_port) { match gw.remove_port(convert_llpt(llpt), mapped_port) {
@ -230,10 +230,10 @@ impl IGDManager {
} }
// Get local ip address // Get local ip address
let local_ip = Self::find_local_ip(&mut *inner, at)?; let local_ip = Self::find_local_ip(&mut inner, at)?;
// Find gateway // Find gateway
let gw = Self::find_gateway(&mut *inner, at)?; let gw = Self::find_gateway(&mut inner, at)?;
// Get external address // Get external address
let ext_ip = match gw.get_external_ip() { let ext_ip = match gw.get_external_ip() {
@ -245,16 +245,12 @@ impl IGDManager {
}; };
// Ensure external IP matches address type // Ensure external IP matches address type
if ext_ip.is_ipv4() { if ext_ip.is_ipv4() && at != AddressType::IPV4 {
if at != AddressType::IPV4 { log_net!(debug "mismatched ip address type from igd, wanted v4, got v6");
log_net!(debug "mismatched ip address type from igd, wanted v4, got v6"); return None;
return None; } else if ext_ip.is_ipv6() && at != AddressType::IPV6 {
} log_net!(debug "mismatched ip address type from igd, wanted v6, got v4");
} else if ext_ip.is_ipv6() { return None;
if at != AddressType::IPV6 {
log_net!(debug "mismatched ip address type from igd, wanted v6, got v4");
return None;
}
} }
if let Some(expected_external_address) = expected_external_address { if let Some(expected_external_address) = expected_external_address {

14
veilid-core/src/network_manager/native/mod.rs
View File

@ -421,7 +421,7 @@ impl Network {
if self if self
.network_manager() .network_manager()
.address_filter() .address_filter()
.is_ip_addr_punished(dial_info.address().to_ip_addr()) .is_ip_addr_punished(dial_info.address().ip_addr())
{ {
return Ok(NetworkResult::no_connection_other("punished")); return Ok(NetworkResult::no_connection_other("punished"));
} }
@ -491,7 +491,7 @@ impl Network {
if self if self
.network_manager() .network_manager()
.address_filter() .address_filter()
.is_ip_addr_punished(dial_info.address().to_ip_addr()) .is_ip_addr_punished(dial_info.address().ip_addr())
{ {
return Ok(NetworkResult::no_connection_other("punished")); return Ok(NetworkResult::no_connection_other("punished"));
} }
@ -519,7 +519,7 @@ impl Network {
.into_network_result()) .into_network_result())
.wrap_err("recv_message failure")?; .wrap_err("recv_message failure")?;
let recv_socket_addr = recv_addr.remote_address().to_socket_addr(); let recv_socket_addr = recv_addr.remote_address().socket_addr();
self.network_manager() self.network_manager()
.stats_packet_rcvd(recv_socket_addr.ip(), ByteCount::new(recv_len as u64)); .stats_packet_rcvd(recv_socket_addr.ip(), ByteCount::new(recv_len as u64));
@ -583,10 +583,10 @@ impl Network {
// Handle connectionless protocol // Handle connectionless protocol
if descriptor.protocol_type() == ProtocolType::UDP { if descriptor.protocol_type() == ProtocolType::UDP {
// send over the best udp socket we have bound since UDP is not connection oriented // send over the best udp socket we have bound since UDP is not connection oriented
let peer_socket_addr = descriptor.remote().to_socket_addr(); let peer_socket_addr = descriptor.remote().socket_addr();
if let Some(ph) = self.find_best_udp_protocol_handler( if let Some(ph) = self.find_best_udp_protocol_handler(
&peer_socket_addr, &peer_socket_addr,
&descriptor.local().map(|sa| sa.to_socket_addr()), &descriptor.local().map(|sa| sa.socket_addr()),
) { ) {
network_result_value_or_log!(ph.clone() network_result_value_or_log!(ph.clone()
.send_message(data.clone(), peer_socket_addr) .send_message(data.clone(), peer_socket_addr)
@ -612,7 +612,7 @@ impl Network {
ConnectionHandleSendResult::Sent => { ConnectionHandleSendResult::Sent => {
// Network accounting // Network accounting
self.network_manager().stats_packet_sent( self.network_manager().stats_packet_sent(
descriptor.remote().to_socket_addr().ip(), descriptor.remote().socket_addr().ip(),
ByteCount::new(data_len as u64), ByteCount::new(data_len as u64),
); );
@ -701,7 +701,7 @@ impl Network {
.with_interfaces(|interfaces| { .with_interfaces(|interfaces| {
trace!("interfaces: {:#?}", interfaces); trace!("interfaces: {:#?}", interfaces);
for (_name, intf) in interfaces { for intf in interfaces.values() {
// Skip networks that we should never encounter // Skip networks that we should never encounter
if intf.is_loopback() || !intf.is_running() { if intf.is_loopback() || !intf.is_running() {
continue; continue;

2
veilid-core/src/network_manager/native/network_udp.rs
View File

@ -68,7 +68,7 @@ impl Network {
Ok(Ok((size, descriptor))) => { Ok(Ok((size, descriptor))) => {
// Network accounting // Network accounting
network_manager.stats_packet_rcvd( network_manager.stats_packet_rcvd(
descriptor.remote_address().to_ip_addr(), descriptor.remote_address().ip_addr(),
ByteCount::new(size as u64), ByteCount::new(size as u64),
); );

2
veilid-core/src/network_manager/native/protocol/mod.rs
View File

@ -24,7 +24,7 @@ impl ProtocolNetworkConnection {
timeout_ms: u32, timeout_ms: u32,
address_filter: AddressFilter, address_filter: AddressFilter,
) -> io::Result<NetworkResult<ProtocolNetworkConnection>> { ) -> io::Result<NetworkResult<ProtocolNetworkConnection>> {
if address_filter.is_ip_addr_punished(dial_info.address().to_ip_addr()) { if address_filter.is_ip_addr_punished(dial_info.address().ip_addr()) {
return Ok(NetworkResult::no_connection_other("punished")); return Ok(NetworkResult::no_connection_other("punished"));
} }
match dial_info.protocol_type() { match dial_info.protocol_type() {

7
veilid-core/src/network_manager/native/protocol/tcp.rs
View File

@ -19,7 +19,7 @@ impl RawTcpNetworkConnection {
} }
pub fn descriptor(&self) -> ConnectionDescriptor { pub fn descriptor(&self) -> ConnectionDescriptor {
self.descriptor.clone() self.descriptor
} }
// #[instrument(level = "trace", err, skip(self))] // #[instrument(level = "trace", err, skip(self))]
@ -132,11 +132,12 @@ impl RawTcpProtocolHandler {
) -> io::Result<Option<ProtocolNetworkConnection>> { ) -> io::Result<Option<ProtocolNetworkConnection>> {
log_net!("TCP: on_accept_async: enter"); log_net!("TCP: on_accept_async: enter");
let mut peekbuf: [u8; PEEK_DETECT_LEN] = [0u8; PEEK_DETECT_LEN]; let mut peekbuf: [u8; PEEK_DETECT_LEN] = [0u8; PEEK_DETECT_LEN];
if let Err(_) = timeout( if (timeout(
self.connection_initial_timeout_ms, self.connection_initial_timeout_ms,
ps.peek_exact(&mut peekbuf), ps.peek_exact(&mut peekbuf),
) )
.await .await)
.is_err()
{ {
return Ok(None); return Ok(None);
} }

8
veilid-core/src/network_manager/native/protocol/udp.rs
View File

@ -79,9 +79,9 @@ impl RawUdpProtocolHandler {
}; };
#[cfg(feature = "verbose-tracing")] #[cfg(feature = "verbose-tracing")]
tracing::Span::current().record("ret.len", &message_len); tracing::Span::current().record("ret.len", message_len);
#[cfg(feature = "verbose-tracing")] #[cfg(feature = "verbose-tracing")]
tracing::Span::current().record("ret.descriptor", &format!("{:?}", descriptor).as_str()); tracing::Span::current().record("ret.descriptor", format!("{:?}", descriptor).as_str());
Ok((message_len, descriptor)) Ok((message_len, descriptor))
} }
@ -134,7 +134,7 @@ impl RawUdpProtocolHandler {
); );
#[cfg(feature = "verbose-tracing")] #[cfg(feature = "verbose-tracing")]
tracing::Span::current().record("ret.descriptor", &format!("{:?}", descriptor).as_str()); tracing::Span::current().record("ret.descriptor", format!("{:?}", descriptor).as_str());
Ok(NetworkResult::value(descriptor)) Ok(NetworkResult::value(descriptor))
} }
@ -143,7 +143,7 @@ impl RawUdpProtocolHandler {
socket_addr: &SocketAddr, socket_addr: &SocketAddr,
) -> io::Result<RawUdpProtocolHandler> { ) -> io::Result<RawUdpProtocolHandler> {
// get local wildcard address for bind // get local wildcard address for bind
let local_socket_addr = compatible_unspecified_socket_addr(&socket_addr); let local_socket_addr = compatible_unspecified_socket_addr(socket_addr);
let socket = UdpSocket::bind(local_socket_addr).await?; let socket = UdpSocket::bind(local_socket_addr).await?;
Ok(RawUdpProtocolHandler::new(Arc::new(socket), None)) Ok(RawUdpProtocolHandler::new(Arc::new(socket), None))
} }

9
veilid-core/src/network_manager/native/protocol/ws.rs
View File

@ -20,7 +20,7 @@ const MAX_WS_BEFORE_BODY: usize = 2048;
cfg_if! { cfg_if! {
if #[cfg(feature="rt-async-std")] { if #[cfg(feature="rt-async-std")] {
pub type WebsocketNetworkConnectionWSS = pub type WebsocketNetworkConnectionWSS =
WebsocketNetworkConnection<async_tls::client::TlsStream<TcpStream>>; DialInfo::WS { field1: _ }ketNetworkConnection<async_tls::client::TlsStream<TcpStream>>;
pub type WebsocketNetworkConnectionWS = WebsocketNetworkConnection<TcpStream>; pub type WebsocketNetworkConnectionWS = WebsocketNetworkConnection<TcpStream>;
} else if #[cfg(feature="rt-tokio")] { } else if #[cfg(feature="rt-tokio")] {
pub type WebsocketNetworkConnectionWSS = pub type WebsocketNetworkConnectionWSS =
@ -74,7 +74,7 @@ where
} }
pub fn descriptor(&self) -> ConnectionDescriptor { pub fn descriptor(&self) -> ConnectionDescriptor {
self.descriptor.clone() self.descriptor
} }
// #[instrument(level = "trace", err, skip(self))] // #[instrument(level = "trace", err, skip(self))]
@ -232,7 +232,7 @@ impl WebsocketProtocolHandler {
// This check could be loosened if necessary, but until we have a reason to do so // This check could be loosened if necessary, but until we have a reason to do so
// a stricter interpretation of HTTP is possible and desirable to reduce attack surface // a stricter interpretation of HTTP is possible and desirable to reduce attack surface
if peek_buf.windows(4).position(|w| w == b"\r\n\r\n").is_none() { if !peek_buf.windows(4).any(|w| w == b"\r\n\r\n") {
return Ok(None); return Ok(None);
} }
@ -339,8 +339,7 @@ impl Callback for WebsocketProtocolHandler {
|| request || request
.headers() .headers()
.iter() .iter()
.find(|h| (h.0.as_str().len() + h.1.as_bytes().len()) > MAX_WS_HEADER_LENGTH) .any(|h| (h.0.as_str().len() + h.1.as_bytes().len()) > MAX_WS_HEADER_LENGTH)
.is_some()
{ {
let mut error_response = ErrorResponse::new(None); let mut error_response = ErrorResponse::new(None);
*error_response.status_mut() = StatusCode::NOT_FOUND; *error_response.status_mut() = StatusCode::NOT_FOUND;

6
veilid-core/src/network_manager/native/start_protocols.rs
View File

@ -312,7 +312,7 @@ impl Network {
// if no other public address is specified // if no other public address is specified
if !detect_address_changes if !detect_address_changes
&& public_address.is_none() && public_address.is_none()
&& routing_table.ensure_dial_info_is_valid(RoutingDomain::PublicInternet, &di) && routing_table.ensure_dial_info_is_valid(RoutingDomain::PublicInternet, di)
{ {
editor_public_internet.register_dial_info(di.clone(), DialInfoClass::Direct)?; editor_public_internet.register_dial_info(di.clone(), DialInfoClass::Direct)?;
static_public = true; static_public = true;
@ -449,7 +449,7 @@ impl Network {
for socket_address in socket_addresses { for socket_address in socket_addresses {
// Skip addresses we already did // Skip addresses we already did
if registered_addresses.contains(&socket_address.to_ip_addr()) { if registered_addresses.contains(&socket_address.ip_addr()) {
continue; continue;
} }
// Build dial info request url // Build dial info request url
@ -628,7 +628,7 @@ impl Network {
} }
// Register interface dial info // Register interface dial info
editor_local_network.register_dial_info(di.clone(), DialInfoClass::Direct)?; editor_local_network.register_dial_info(di.clone(), DialInfoClass::Direct)?;
registered_addresses.insert(socket_address.to_ip_addr()); registered_addresses.insert(socket_address.ip_addr());
} }
// Add static public dialinfo if it's configured // Add static public dialinfo if it's configured

19
veilid-core/src/network_manager/network_connection.rs
View File

@ -52,7 +52,7 @@ pub struct DummyNetworkConnection {
impl DummyNetworkConnection { impl DummyNetworkConnection {
pub fn descriptor(&self) -> ConnectionDescriptor { pub fn descriptor(&self) -> ConnectionDescriptor {
self.descriptor.clone() self.descriptor
} }
// pub fn close(&self) -> io::Result<()> { // pub fn close(&self) -> io::Result<()> {
// Ok(()) // Ok(())
@ -144,7 +144,7 @@ impl NetworkConnection {
local_stop_token, local_stop_token,
manager_stop_token, manager_stop_token,
connection_id, connection_id,
descriptor.clone(), descriptor,
receiver, receiver,
protocol_connection, protocol_connection,
stats.clone(), stats.clone(),
@ -168,11 +168,11 @@ impl NetworkConnection {
} }
pub fn connection_descriptor(&self) -> ConnectionDescriptor { pub fn connection_descriptor(&self) -> ConnectionDescriptor {
self.descriptor.clone() self.descriptor
} }
pub fn get_handle(&self) -> ConnectionHandle { pub fn get_handle(&self) -> ConnectionHandle {
ConnectionHandle::new(self.connection_id, self.descriptor.clone(), self.sender.clone()) ConnectionHandle::new(self.connection_id, self.descriptor, self.sender.clone())
} }
pub fn is_protected(&self) -> bool { pub fn is_protected(&self) -> bool {
@ -197,12 +197,12 @@ impl NetworkConnection {
message: Vec<u8>, message: Vec<u8>,
) -> io::Result<NetworkResult<()>> { ) -> io::Result<NetworkResult<()>> {
let ts = get_aligned_timestamp(); let ts = get_aligned_timestamp();
let out = network_result_try!(protocol_connection.send(message).await?); network_result_try!(protocol_connection.send(message).await?);
let mut stats = stats.lock(); let mut stats = stats.lock();
stats.last_message_sent_time.max_assign(Some(ts)); stats.last_message_sent_time.max_assign(Some(ts));
Ok(NetworkResult::Value(out)) Ok(NetworkResult::Value(()))
} }
#[cfg_attr(feature="verbose-tracing", instrument(level="trace", skip(stats), fields(ret.len)))] #[cfg_attr(feature="verbose-tracing", instrument(level="trace", skip(stats), fields(ret.len)))]
@ -234,6 +234,7 @@ impl NetworkConnection {
} }
// Connection receiver loop // Connection receiver loop
#[allow(clippy::too_many_arguments)]
fn process_connection( fn process_connection(
connection_manager: ConnectionManager, connection_manager: ConnectionManager,
local_stop_token: StopToken, local_stop_token: StopToken,
@ -316,19 +317,19 @@ impl NetworkConnection {
let peer_address = protocol_connection.descriptor().remote(); let peer_address = protocol_connection.descriptor().remote();
// Check to see if it is punished // Check to see if it is punished
if address_filter.is_ip_addr_punished(peer_address.to_socket_addr().ip()) { if address_filter.is_ip_addr_punished(peer_address.socket_addr().ip()) {
return RecvLoopAction::Finish; return RecvLoopAction::Finish;
} }
// Check for connection close // Check for connection close
if v.is_no_connection() { if v.is_no_connection() {
log_net!(debug "Connection closed from: {} ({})", peer_address.to_socket_addr(), peer_address.protocol_type()); log_net!(debug "Connection closed from: {} ({})", peer_address.socket_addr(), peer_address.protocol_type());
return RecvLoopAction::Finish; return RecvLoopAction::Finish;
} }
// Punish invalid framing (tcp framing or websocket framing) // Punish invalid framing (tcp framing or websocket framing)
if v.is_invalid_message() { if v.is_invalid_message() {
address_filter.punish_ip_addr(peer_address.to_socket_addr().ip()); address_filter.punish_ip_addr(peer_address.socket_addr().ip());
return RecvLoopAction::Finish; return RecvLoopAction::Finish;
} }

2
veilid-core/src/network_manager/send_data.rs
View File

@ -338,7 +338,7 @@ impl NetworkManager {
let routing_table = self.routing_table(); let routing_table = self.routing_table();
// If a node is punished, then don't try to contact it // If a node is punished, then don't try to contact it
if target_node_ref.node_ids().iter().find(|nid| self.address_filter().is_node_id_punished(**nid)).is_some() { if target_node_ref.node_ids().iter().any(|nid| self.address_filter().is_node_id_punished(*nid)) {
return Ok(NodeContactMethod::Unreachable); return Ok(NodeContactMethod::Unreachable);
} }

10
veilid-core/src/network_manager/tasks/public_address_check.rs
View File

@ -11,7 +11,7 @@ impl NetworkManager {
) -> EyreResult<()> { ) -> EyreResult<()> {
// go through public_address_inconsistencies_table and time out things that have expired // go through public_address_inconsistencies_table and time out things that have expired
let mut inner = self.inner.lock(); let mut inner = self.inner.lock();
for (_, pait_v) in &mut inner.public_address_inconsistencies_table { for pait_v in inner.public_address_inconsistencies_table.values_mut() {
let mut expired = Vec::new(); let mut expired = Vec::new();
for (addr, exp_ts) in pait_v.iter() { for (addr, exp_ts) in pait_v.iter() {
if *exp_ts <= cur_ts { if *exp_ts <= cur_ts {
@ -79,7 +79,7 @@ impl NetworkManager {
// Get the ip(block) this report is coming from // Get the ip(block) this report is coming from
let reporting_ipblock = ip_to_ipblock( let reporting_ipblock = ip_to_ipblock(
ip6_prefix_size, ip6_prefix_size,
connection_descriptor.remote_address().to_ip_addr(), connection_descriptor.remote_address().ip_addr(),
); );
// Reject public address reports from nodes that we know are behind symmetric nat or // Reject public address reports from nodes that we know are behind symmetric nat or
@ -94,7 +94,7 @@ impl NetworkManager {
// If the socket address reported is the same as the reporter, then this is coming through a relay // If the socket address reported is the same as the reporter, then this is coming through a relay
// or it should be ignored due to local proximity (nodes on the same network block should not be trusted as // or it should be ignored due to local proximity (nodes on the same network block should not be trusted as
// public ip address reporters, only disinterested parties) // public ip address reporters, only disinterested parties)
if reporting_ipblock == ip_to_ipblock(ip6_prefix_size, socket_address.to_ip_addr()) { if reporting_ipblock == ip_to_ipblock(ip6_prefix_size, socket_address.ip_addr()) {
return; return;
} }
@ -192,7 +192,7 @@ impl NetworkManager {
let pait = inner let pait = inner
.public_address_inconsistencies_table .public_address_inconsistencies_table
.entry(addr_proto_type_key) .entry(addr_proto_type_key)
.or_insert_with(|| HashMap::new()); .or_insert_with(HashMap::new);
for i in &inconsistencies { for i in &inconsistencies {
pait.insert(*i, exp_ts); pait.insert(*i, exp_ts);
} }
@ -204,7 +204,7 @@ impl NetworkManager {
let pait = inner let pait = inner
.public_address_inconsistencies_table .public_address_inconsistencies_table
.entry(addr_proto_type_key) .entry(addr_proto_type_key)
.or_insert_with(|| HashMap::new()); .or_insert_with(HashMap::new);
let exp_ts = get_aligned_timestamp() let exp_ts = get_aligned_timestamp()
+ PUBLIC_ADDRESS_INCONSISTENCY_PUNISHMENT_TIMEOUT_US; + PUBLIC_ADDRESS_INCONSISTENCY_PUNISHMENT_TIMEOUT_US;
for i in inconsistencies { for i in inconsistencies {

8
veilid-core/src/network_manager/types/address.rs
View File

@ -71,16 +71,16 @@ impl Address {
} }
} }
} }
pub fn to_ip_addr(&self) -> IpAddr { pub fn ip_addr(&self) -> IpAddr {
match self { match self {
Self::IPV4(a) => IpAddr::V4(*a), Self::IPV4(a) => IpAddr::V4(*a),
Self::IPV6(a) => IpAddr::V6(*a), Self::IPV6(a) => IpAddr::V6(*a),
} }
} }
pub fn to_socket_addr(&self, port: u16) -> SocketAddr { pub fn socket_addr(&self, port: u16) -> SocketAddr {
SocketAddr::new(self.to_ip_addr(), port) SocketAddr::new(self.ip_addr(), port)
} }
pub fn to_canonical(&self) -> Address { pub fn canonical(&self) -> Address {
match self { match self {
Address::IPV4(v4) => Address::IPV4(*v4), Address::IPV4(v4) => Address::IPV4(*v4),
Address::IPV6(v6) => match v6.to_ipv4() { Address::IPV6(v6) => match v6.to_ipv4() {

2
veilid-core/src/network_manager/types/address_type.rs
View File

@ -1,7 +1,7 @@
#![allow(non_snake_case)] #![allow(non_snake_case)]
use super::*; use super::*;
#[allow(clippy::derive_hash_xor_eq)] #[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, PartialOrd, Ord, Hash, Serialize, Deserialize, EnumSetType)] #[derive(Debug, PartialOrd, Ord, Hash, Serialize, Deserialize, EnumSetType)]
#[enumset(repr = "u8")] #[enumset(repr = "u8")]
pub enum AddressType { pub enum AddressType {

48
veilid-core/src/network_manager/types/dial_info/mod.rs
View File

@ -36,10 +36,10 @@ impl fmt::Display for DialInfo {
let split_url = SplitUrl::from_str(&url).unwrap(); let split_url = SplitUrl::from_str(&url).unwrap();
match split_url.host { match split_url.host {
SplitUrlHost::Hostname(_) => { SplitUrlHost::Hostname(_) => {
write!(f, "ws|{}|{}", di.socket_address.to_ip_addr(), di.request) write!(f, "ws|{}|{}", di.socket_address.ip_addr(), di.request)
} }
SplitUrlHost::IpAddr(a) => { SplitUrlHost::IpAddr(a) => {
if di.socket_address.to_ip_addr() == a { if di.socket_address.ip_addr() == a {
write!(f, "ws|{}", di.request) write!(f, "ws|{}", di.request)
} else { } else {
panic!("resolved address does not match url: {}", di.request); panic!("resolved address does not match url: {}", di.request);
@ -52,7 +52,7 @@ impl fmt::Display for DialInfo {
let split_url = SplitUrl::from_str(&url).unwrap(); let split_url = SplitUrl::from_str(&url).unwrap();
match split_url.host { match split_url.host {
SplitUrlHost::Hostname(_) => { SplitUrlHost::Hostname(_) => {
write!(f, "wss|{}|{}", di.socket_address.to_ip_addr(), di.request) write!(f, "wss|{}|{}", di.socket_address.ip_addr(), di.request)
} }
SplitUrlHost::IpAddr(_) => { SplitUrlHost::IpAddr(_) => {
panic!( panic!(
@ -143,22 +143,22 @@ impl FromStr for DialInfo {
impl DialInfo { impl DialInfo {
pub fn udp_from_socketaddr(socket_addr: SocketAddr) -> Self { pub fn udp_from_socketaddr(socket_addr: SocketAddr) -> Self {
Self::UDP(DialInfoUDP { Self::UDP(DialInfoUDP {
socket_address: SocketAddress::from_socket_addr(socket_addr).to_canonical(), socket_address: SocketAddress::from_socket_addr(socket_addr).canonical(),
}) })
} }
pub fn tcp_from_socketaddr(socket_addr: SocketAddr) -> Self { pub fn tcp_from_socketaddr(socket_addr: SocketAddr) -> Self {
Self::TCP(DialInfoTCP { Self::TCP(DialInfoTCP {
socket_address: SocketAddress::from_socket_addr(socket_addr).to_canonical(), socket_address: SocketAddress::from_socket_addr(socket_addr).canonical(),
}) })
} }
pub fn udp(socket_address: SocketAddress) -> Self { pub fn udp(socket_address: SocketAddress) -> Self {
Self::UDP(DialInfoUDP { Self::UDP(DialInfoUDP {
socket_address: socket_address.to_canonical(), socket_address: socket_address.canonical(),
}) })
} }
pub fn tcp(socket_address: SocketAddress) -> Self { pub fn tcp(socket_address: SocketAddress) -> Self {
Self::TCP(DialInfoTCP { Self::TCP(DialInfoTCP {
socket_address: socket_address.to_canonical(), socket_address: socket_address.canonical(),
}) })
} }
pub fn try_ws(socket_address: SocketAddress, url: String) -> VeilidAPIResult<Self> { pub fn try_ws(socket_address: SocketAddress, url: String) -> VeilidAPIResult<Self> {
@ -173,7 +173,7 @@ impl DialInfo {
apibail_parse_error!("socket address port doesn't match url port", url); apibail_parse_error!("socket address port doesn't match url port", url);
} }
if let SplitUrlHost::IpAddr(a) = split_url.host { if let SplitUrlHost::IpAddr(a) = split_url.host {
if socket_address.to_ip_addr() != a { if socket_address.ip_addr() != a {
apibail_parse_error!( apibail_parse_error!(
format!("request address does not match socket address: {}", a), format!("request address does not match socket address: {}", a),
socket_address socket_address
@ -181,7 +181,7 @@ impl DialInfo {
} }
} }
Ok(Self::WS(DialInfoWS { Ok(Self::WS(DialInfoWS {
socket_address: socket_address.to_canonical(), socket_address: socket_address.canonical(),
request: url[5..].to_string(), request: url[5..].to_string(),
})) }))
} }
@ -203,7 +203,7 @@ impl DialInfo {
); );
} }
Ok(Self::WSS(DialInfoWSS { Ok(Self::WSS(DialInfoWSS {
socket_address: socket_address.to_canonical(), socket_address: socket_address.canonical(),
request: url[6..].to_string(), request: url[6..].to_string(),
})) }))
} }
@ -244,10 +244,10 @@ impl DialInfo {
} }
pub fn to_ip_addr(&self) -> IpAddr { pub fn to_ip_addr(&self) -> IpAddr {
match self { match self {
Self::UDP(di) => di.socket_address.to_ip_addr(), Self::UDP(di) => di.socket_address.ip_addr(),
Self::TCP(di) => di.socket_address.to_ip_addr(), Self::TCP(di) => di.socket_address.ip_addr(),
Self::WS(di) => di.socket_address.to_ip_addr(), Self::WS(di) => di.socket_address.ip_addr(),
Self::WSS(di) => di.socket_address.to_ip_addr(), Self::WSS(di) => di.socket_address.ip_addr(),
} }
} }
pub fn port(&self) -> u16 { pub fn port(&self) -> u16 {
@ -268,10 +268,10 @@ impl DialInfo {
} }
pub fn to_socket_addr(&self) -> SocketAddr { pub fn to_socket_addr(&self) -> SocketAddr {
match self { match self {
Self::UDP(di) => di.socket_address.to_socket_addr(), Self::UDP(di) => di.socket_address.socket_addr(),
Self::TCP(di) => di.socket_address.to_socket_addr(), Self::TCP(di) => di.socket_address.socket_addr(),
Self::WS(di) => di.socket_address.to_socket_addr(), Self::WS(di) => di.socket_address.socket_addr(),
Self::WSS(di) => di.socket_address.to_socket_addr(), Self::WSS(di) => di.socket_address.socket_addr(),
} }
} }
pub fn to_peer_address(&self) -> PeerAddress { pub fn to_peer_address(&self) -> PeerAddress {
@ -376,11 +376,11 @@ impl DialInfo {
"udp" => Self::udp_from_socketaddr(sa), "udp" => Self::udp_from_socketaddr(sa),
"tcp" => Self::tcp_from_socketaddr(sa), "tcp" => Self::tcp_from_socketaddr(sa),
"ws" => Self::try_ws( "ws" => Self::try_ws(
SocketAddress::from_socket_addr(sa).to_canonical(), SocketAddress::from_socket_addr(sa).canonical(),
url.to_string(), url.to_string(),
)?, )?,
"wss" => Self::try_wss( "wss" => Self::try_wss(
SocketAddress::from_socket_addr(sa).to_canonical(), SocketAddress::from_socket_addr(sa).canonical(),
url.to_string(), url.to_string(),
)?, )?,
_ => { _ => {
@ -395,13 +395,13 @@ impl DialInfo {
match self { match self {
DialInfo::UDP(di) => ( DialInfo::UDP(di) => (
format!("U{}", di.socket_address.port()), format!("U{}", di.socket_address.port()),
intf::ptr_lookup(di.socket_address.to_ip_addr()) intf::ptr_lookup(di.socket_address.ip_addr())
.await .await
.unwrap_or_else(|_| di.socket_address.to_string()), .unwrap_or_else(|_| di.socket_address.to_string()),
), ),
DialInfo::TCP(di) => ( DialInfo::TCP(di) => (
format!("T{}", di.socket_address.port()), format!("T{}", di.socket_address.port()),
intf::ptr_lookup(di.socket_address.to_ip_addr()) intf::ptr_lookup(di.socket_address.ip_addr())
.await .await
.unwrap_or_else(|_| di.socket_address.to_string()), .unwrap_or_else(|_| di.socket_address.to_string()),
), ),
@ -447,11 +447,11 @@ impl DialInfo {
} }
pub async fn to_url(&self) -> String { pub async fn to_url(&self) -> String {
match self { match self {
DialInfo::UDP(di) => intf::ptr_lookup(di.socket_address.to_ip_addr()) DialInfo::UDP(di) => intf::ptr_lookup(di.socket_address.ip_addr())
.await .await
.map(|h| format!("udp://{}:{}", h, di.socket_address.port())) .map(|h| format!("udp://{}:{}", h, di.socket_address.port()))
.unwrap_or_else(|_| format!("udp://{}", di.socket_address)), .unwrap_or_else(|_| format!("udp://{}", di.socket_address)),
DialInfo::TCP(di) => intf::ptr_lookup(di.socket_address.to_ip_addr()) DialInfo::TCP(di) => intf::ptr_lookup(di.socket_address.ip_addr())
.await .await
.map(|h| format!("tcp://{}:{}", h, di.socket_address.port())) .map(|h| format!("tcp://{}:{}", h, di.socket_address.port()))
.unwrap_or_else(|_| format!("tcp://{}", di.socket_address)), .unwrap_or_else(|_| format!("tcp://{}", di.socket_address)),

2
veilid-core/src/network_manager/types/low_level_protocol_type.rs
View File

@ -4,7 +4,7 @@ use super::*;
// Keep member order appropriate for sorting < preference // Keep member order appropriate for sorting < preference
// Must match DialInfo order // Must match DialInfo order
#[allow(clippy::derive_hash_xor_eq)] #[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)] #[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)]
#[enumset(repr = "u8")] #[enumset(repr = "u8")]
pub enum LowLevelProtocolType { pub enum LowLevelProtocolType {

11
veilid-core/src/network_manager/types/peer_address.rs
View File

@ -10,7 +10,7 @@ pub struct PeerAddress {
impl PeerAddress { impl PeerAddress {
pub fn new(socket_address: SocketAddress, protocol_type: ProtocolType) -> Self { pub fn new(socket_address: SocketAddress, protocol_type: ProtocolType) -> Self {
Self { Self {
socket_address: socket_address.to_canonical(), socket_address: socket_address.canonical(),
protocol_type, protocol_type,
} }
} }
@ -23,8 +23,8 @@ impl PeerAddress {
self.protocol_type self.protocol_type
} }
pub fn to_socket_addr(&self) -> SocketAddr { pub fn socket_addr(&self) -> SocketAddr {
self.socket_address.to_socket_addr() self.socket_address.socket_addr()
} }
pub fn address_type(&self) -> AddressType { pub fn address_type(&self) -> AddressType {
@ -42,7 +42,10 @@ impl FromStr for PeerAddress {
type Err = VeilidAPIError; type Err = VeilidAPIError;
fn from_str(s: &str) -> VeilidAPIResult<PeerAddress> { fn from_str(s: &str) -> VeilidAPIResult<PeerAddress> {
let Some((first, second)) = s.split_once(':') else { let Some((first, second)) = s.split_once(':') else {
return Err(VeilidAPIError::parse_error("PeerAddress is missing a colon: {}", s)); return Err(VeilidAPIError::parse_error(
"PeerAddress is missing a colon: {}",
s,
));
}; };
let protocol_type = ProtocolType::from_str(first)?; let protocol_type = ProtocolType::from_str(first)?;
let socket_address = SocketAddress::from_str(second)?; let socket_address = SocketAddress::from_str(second)?;

2
veilid-core/src/network_manager/types/protocol_type.rs
View File

@ -3,7 +3,7 @@ use super::*;
// Keep member order appropriate for sorting < preference // Keep member order appropriate for sorting < preference
// Must match DialInfo order // Must match DialInfo order
#[allow(clippy::derive_hash_xor_eq)] #[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)] #[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)]
#[enumset(repr = "u8")] #[enumset(repr = "u8")]
pub enum ProtocolType { pub enum ProtocolType {

16
veilid-core/src/network_manager/types/socket_address.rs
View File

@ -34,27 +34,27 @@ impl SocketAddress {
self.port = port self.port = port
} }
pub fn with_port(&self, port: u16) -> Self { pub fn with_port(&self, port: u16) -> Self {
let mut sa = self.clone(); let mut sa = *self;
sa.port = port; sa.port = port;
sa sa
} }
pub fn to_canonical(&self) -> SocketAddress { pub fn canonical(&self) -> SocketAddress {
SocketAddress { SocketAddress {
address: self.address.to_canonical(), address: self.address.canonical(),
port: self.port, port: self.port,
} }
} }
pub fn to_ip_addr(&self) -> IpAddr { pub fn ip_addr(&self) -> IpAddr {
self.address.to_ip_addr() self.address.ip_addr()
} }
pub fn to_socket_addr(&self) -> SocketAddr { pub fn socket_addr(&self) -> SocketAddr {
self.address.to_socket_addr(self.port) self.address.socket_addr(self.port)
} }
} }
impl fmt::Display for SocketAddress { impl fmt::Display for SocketAddress {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
write!(f, "{}", self.to_socket_addr()) write!(f, "{}", self.socket_addr())
} }
} }

6
veilid-core/src/routing_table/bucket_entry.rs
View File

@ -223,7 +223,7 @@ impl BucketEntryInner {
// Lower timestamp to the front, recent or no timestamp is at the end // Lower timestamp to the front, recent or no timestamp is at the end
if let Some(e1_ts) = &e1.peer_stats.rpc_stats.first_consecutive_seen_ts { if let Some(e1_ts) = &e1.peer_stats.rpc_stats.first_consecutive_seen_ts {
if let Some(e2_ts) = &e2.peer_stats.rpc_stats.first_consecutive_seen_ts { if let Some(e2_ts) = &e2.peer_stats.rpc_stats.first_consecutive_seen_ts {
e1_ts.cmp(&e2_ts) e1_ts.cmp(e2_ts)
} else { } else {
std::cmp::Ordering::Less std::cmp::Ordering::Less
} }
@ -437,7 +437,7 @@ impl BucketEntryInner {
// Clears the table of last connections except the most recent one // Clears the table of last connections except the most recent one
pub fn clear_last_connections_except_latest(&mut self) { pub fn clear_last_connections_except_latest(&mut self) {
if self.last_connections.len() == 0 { if self.last_connections.is_empty() {
// No last_connections // No last_connections
return; return;
} }
@ -454,7 +454,7 @@ impl BucketEntryInner {
let Some(most_recent_connection) = most_recent_connection else { let Some(most_recent_connection) = most_recent_connection else {
return; return;
}; };
for (k, _) in &self.last_connections { for k in self.last_connections.keys() {
if k != most_recent_connection { if k != most_recent_connection {
dead_keys.push(k.clone()); dead_keys.push(k.clone());
} }

8
veilid-core/src/routing_table/mod.rs
View File

@ -388,11 +388,15 @@ impl RoutingTable {
} }
// Caches valid, load saved routing table // Caches valid, load saved routing table
let Some(serialized_bucket_map): Option<SerializedBucketMap> = db.load_json(0, SERIALIZED_BUCKET_MAP).await? else { let Some(serialized_bucket_map): Option<SerializedBucketMap> =
db.load_json(0, SERIALIZED_BUCKET_MAP).await?
else {
log_rtab!(debug "no bucket map in saved routing table"); log_rtab!(debug "no bucket map in saved routing table");
return Ok(()); return Ok(());
}; };
let Some(all_entry_bytes): Option<SerializedBuckets> = db.load_json(0, ALL_ENTRY_BYTES).await? else { let Some(all_entry_bytes): Option<SerializedBuckets> =
db.load_json(0, ALL_ENTRY_BYTES).await?
else {
log_rtab!(debug "no all_entry_bytes in saved routing table"); log_rtab!(debug "no all_entry_bytes in saved routing table");
return Ok(()); return Ok(());
}; };

8
veilid-core/src/routing_table/routing_domain_editor.rs
View File

@ -258,11 +258,9 @@ impl RoutingDomainEditor {
} }
} }
// Clear the routespecstore cache if our PublicInternet dial info has changed // Clear the routespecstore cache if our PublicInternet dial info has changed
if changed { if changed && self.routing_domain == RoutingDomain::PublicInternet {
if self.routing_domain == RoutingDomain::PublicInternet { let rss = self.routing_table.route_spec_store();
let rss = self.routing_table.route_spec_store(); rss.reset();
rss.reset();
}
} }
} }
} }

24
veilid-core/src/routing_table/routing_domains.rs
View File

@ -250,7 +250,7 @@ pub trait RoutingDomainDetail {
peer_b: &PeerInfo, peer_b: &PeerInfo,
dial_info_filter: DialInfoFilter, dial_info_filter: DialInfoFilter,
sequencing: Sequencing, sequencing: Sequencing,
dif_sort: Option<Arc<dyn Fn(&DialInfoDetail, &DialInfoDetail) -> core::cmp::Ordering>>, dif_sort: Option<Arc<DialInfoDetailSort>>,
) -> ContactMethod; ) -> ContactMethod;
} }
@ -301,12 +301,10 @@ fn first_filtered_dial_info_detail_between_nodes(
} else { } else {
Some(Box::new(move |a,b| { DialInfoDetail::ordered_sequencing_sort(a,b) })) Some(Box::new(move |a,b| { DialInfoDetail::ordered_sequencing_sort(a,b) }))
} }
} else if let Some(dif_sort) = dif_sort {
Some(Box::new(move |a,b| { dif_sort(a,b) }))
} else { } else {
if let Some(dif_sort) = dif_sort { None
Some(Box::new(move |a,b| { dif_sort(a,b) }))
} else {
None
}
}; };
// If the filter is dead then we won't be able to connect // If the filter is dead then we won't be able to connect
@ -336,7 +334,7 @@ impl RoutingDomainDetail for PublicInternetRoutingDomainDetail {
peer_b: &PeerInfo, peer_b: &PeerInfo,
dial_info_filter: DialInfoFilter, dial_info_filter: DialInfoFilter,
sequencing: Sequencing, sequencing: Sequencing,
dif_sort: Option<Arc<dyn Fn(&DialInfoDetail, &DialInfoDetail) -> core::cmp::Ordering>>, dif_sort: Option<Arc<DialInfoDetailSort>>,
) -> ContactMethod { ) -> ContactMethod {
// Get the nodeinfos for convenience // Get the nodeinfos for convenience
let node_a = peer_a.signed_node_info().node_info(); let node_a = peer_a.signed_node_info().node_info();
@ -554,7 +552,7 @@ impl RoutingDomainDetail for LocalNetworkRoutingDomainDetail {
&mut self.common &mut self.common
} }
fn can_contain_address(&self, address: Address) -> bool { fn can_contain_address(&self, address: Address) -> bool {
let ip = address.to_ip_addr(); let ip = address.ip_addr();
for localnet in &self.local_networks { for localnet in &self.local_networks {
if ipaddr_in_network(ip, localnet.0, localnet.1) { if ipaddr_in_network(ip, localnet.0, localnet.1) {
return true; return true;
@ -570,7 +568,7 @@ impl RoutingDomainDetail for LocalNetworkRoutingDomainDetail {
peer_b: &PeerInfo, peer_b: &PeerInfo,
dial_info_filter: DialInfoFilter, dial_info_filter: DialInfoFilter,
sequencing: Sequencing, sequencing: Sequencing,
dif_sort: Option<Arc<dyn Fn(&DialInfoDetail, &DialInfoDetail) -> core::cmp::Ordering>>, dif_sort: Option<Arc<DialInfoDetailSort>>,
) -> ContactMethod { ) -> ContactMethod {
// Scope the filter down to protocols node A can do outbound // Scope the filter down to protocols node A can do outbound
let dial_info_filter = dial_info_filter.filtered( let dial_info_filter = dial_info_filter.filtered(
@ -596,12 +594,10 @@ impl RoutingDomainDetail for LocalNetworkRoutingDomainDetail {
} else { } else {
Some(Box::new(move |a,b| { DialInfoDetail::ordered_sequencing_sort(a,b) })) Some(Box::new(move |a,b| { DialInfoDetail::ordered_sequencing_sort(a,b) }))
} }
} else if let Some(dif_sort) = dif_sort {
Some(Box::new(move |a,b| { dif_sort(a,b) }))
} else { } else {
if let Some(dif_sort) = dif_sort { None
Some(Box::new(move |a,b| { dif_sort(a,b) }))
} else {
None
}
}; };
// If the filter is dead then we won't be able to connect // If the filter is dead then we won't be able to connect

7
veilid-core/src/routing_table/routing_table_inner.rs
View File

@ -550,10 +550,9 @@ impl RoutingTableInner {
} }
// If we don't have node status for this node, then we should ping it to get some node status // If we don't have node status for this node, then we should ping it to get some node status
if e.has_node_info(routing_domain.into()) { if e.has_node_info(routing_domain.into()) && e.node_status(routing_domain).is_none()
if e.node_status(routing_domain).is_none() { {
return true; return true;
}
} }
// If this entry needs a ping because this node hasn't seen our latest node info, then do it // If this entry needs a ping because this node hasn't seen our latest node info, then do it

2
veilid-core/src/routing_table/tasks/bootstrap.rs
View File

@ -327,7 +327,7 @@ impl RoutingTable {
} }
} }
} }
if bootstrap_dialinfos.len() > 0 { if !bootstrap_dialinfos.is_empty() {
return self return self
.direct_bootstrap_task_routine(stop_token, bootstrap_dialinfos) .direct_bootstrap_task_routine(stop_token, bootstrap_dialinfos)
.await; .await;

11
veilid-core/src/routing_table/tasks/private_route_management.rs
View File

@ -78,8 +78,11 @@ impl RoutingTable {
// Save up to N unpublished routes and test them // Save up to N unpublished routes and test them
let background_safety_route_count = self.get_background_safety_route_count(); let background_safety_route_count = self.get_background_safety_route_count();
for x in 0..(usize::min(background_safety_route_count, unpublished_routes.len())) { for unpublished_route in unpublished_routes.iter().take(usize::min(
must_test_routes.push(unpublished_routes[x].0); background_safety_route_count,
unpublished_routes.len(),
)) {
must_test_routes.push(unpublished_route.0);
} }
// Kill off all but N unpublished routes rather than testing them // Kill off all but N unpublished routes rather than testing them
@ -225,9 +228,9 @@ impl RoutingTable {
let remote_routes_needing_testing = rss.list_remote_routes(|k, v| { let remote_routes_needing_testing = rss.list_remote_routes(|k, v| {
let stats = v.get_stats(); let stats = v.get_stats();
if stats.needs_testing(cur_ts) { if stats.needs_testing(cur_ts) {
return Some(*k); Some(*k)
} else { } else {
return None; None
} }
}); });
if !remote_routes_needing_testing.is_empty() { if !remote_routes_needing_testing.is_empty() {

2
veilid-core/src/routing_table/types/dial_info_detail.rs
View File

@ -13,6 +13,8 @@ impl MatchesDialInfoFilter for DialInfoDetail {
} }
} }
pub type DialInfoDetailSort = dyn Fn(&DialInfoDetail, &DialInfoDetail) -> core::cmp::Ordering;
impl DialInfoDetail { impl DialInfoDetail {
pub fn ordered_sequencing_sort(a: &DialInfoDetail, b: &DialInfoDetail) -> core::cmp::Ordering { pub fn ordered_sequencing_sort(a: &DialInfoDetail, b: &DialInfoDetail) -> core::cmp::Ordering {
let c = DialInfo::ordered_sequencing_sort(&a.dial_info, &b.dial_info); let c = DialInfo::ordered_sequencing_sort(&a.dial_info, &b.dial_info);

2
veilid-core/src/routing_table/types/direction.rs
View File

@ -2,7 +2,7 @@
use super::*; use super::*;
#[allow(clippy::derive_hash_xor_eq)] #[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)] #[derive(Debug, PartialOrd, Ord, Hash, EnumSetType, Serialize, Deserialize)]
#[enumset(repr = "u8")] #[enumset(repr = "u8")]
pub enum Direction { pub enum Direction {

2
veilid-core/src/routing_table/types/peer_info.rs
View File

@ -8,7 +8,7 @@ pub struct PeerInfo {
impl PeerInfo { impl PeerInfo {
pub fn new(node_ids: TypedKeyGroup, signed_node_info: SignedNodeInfo) -> Self { pub fn new(node_ids: TypedKeyGroup, signed_node_info: SignedNodeInfo) -> Self {
assert!(node_ids.len() > 0 && node_ids.len() <= MAX_CRYPTO_KINDS); assert!(!node_ids.is_empty() && node_ids.len() <= MAX_CRYPTO_KINDS);
Self { Self {
node_ids, node_ids,
signed_node_info, signed_node_info,

2
veilid-core/src/routing_table/types/routing_domain.rs
View File

@ -3,7 +3,7 @@
use super::*; use super::*;
// Routing domain here is listed in order of preference, keep in order // Routing domain here is listed in order of preference, keep in order
#[allow(clippy::derive_hash_xor_eq)] #[allow(clippy::derived_hash_with_manual_eq)]
#[derive(Debug, Ord, PartialOrd, Hash, EnumSetType, Serialize, Deserialize)] #[derive(Debug, Ord, PartialOrd, Hash, EnumSetType, Serialize, Deserialize)]
#[enumset(repr = "u8")] #[enumset(repr = "u8")]
pub enum RoutingDomain { pub enum RoutingDomain {

2
veilid-core/src/routing_table/types/signed_direct_node_info.rs
View File

@ -29,7 +29,7 @@ impl SignedDirectNodeInfo {
// Verify the signatures that we can // Verify the signatures that we can
let validated_node_ids = let validated_node_ids =
crypto.verify_signatures(node_ids, &node_info_bytes, &self.signatures)?; crypto.verify_signatures(node_ids, &node_info_bytes, &self.signatures)?;
if validated_node_ids.len() == 0 { if validated_node_ids.is_empty() {
apibail_generic!("no valid node ids in direct node info"); apibail_generic!("no valid node ids in direct node info");
} }

4
veilid-core/src/routing_table/types/signed_node_info.rs
View File

@ -33,8 +33,8 @@ impl SignedNodeInfo {
} }
pub fn node_info(&self) -> &NodeInfo { pub fn node_info(&self) -> &NodeInfo {
match self { match self {
SignedNodeInfo::Direct(d) => &d.node_info(), SignedNodeInfo::Direct(d) => d.node_info(),
SignedNodeInfo::Relayed(r) => &r.node_info(), SignedNodeInfo::Relayed(r) => r.node_info(),
} }
} }
pub fn relay_ids(&self) -> TypedKeyGroup { pub fn relay_ids(&self) -> TypedKeyGroup {

2
veilid-core/src/routing_table/types/signed_relayed_node_info.rs
View File

@ -55,7 +55,7 @@ impl SignedRelayedNodeInfo {
)?; )?;
let validated_node_ids = let validated_node_ids =
crypto.verify_signatures(node_ids, &node_info_bytes, &self.signatures)?; crypto.verify_signatures(node_ids, &node_info_bytes, &self.signatures)?;
if validated_node_ids.len() == 0 { if validated_node_ids.is_empty() {
apibail_generic!("no valid node ids in relayed node info"); apibail_generic!("no valid node ids in relayed node info");
} }
Ok(validated_node_ids) Ok(validated_node_ids)

16
veilid-core/src/storage_manager/mod.rs
View File

@ -474,21 +474,21 @@ impl StorageManager {
pub async fn watch_values( pub async fn watch_values(
&self, &self,
key: TypedKey, _key: TypedKey,
subkeys: ValueSubkeyRangeSet, _subkeys: ValueSubkeyRangeSet,
expiration: Timestamp, _expiration: Timestamp,
count: u32, _count: u32,
) -> VeilidAPIResult<Timestamp> { ) -> VeilidAPIResult<Timestamp> {
let inner = self.lock().await?; let _inner = self.lock().await?;
unimplemented!(); unimplemented!();
} }
pub async fn cancel_watch_values( pub async fn cancel_watch_values(
&self, &self,
key: TypedKey, _key: TypedKey,
subkeys: ValueSubkeyRangeSet, _subkeys: ValueSubkeyRangeSet,
) -> VeilidAPIResult<bool> { ) -> VeilidAPIResult<bool> {
let inner = self.lock().await?; let _inner = self.lock().await?;
unimplemented!(); unimplemented!();
} }
} }

14
veilid-core/src/veilid_api/debug.rs
View File

@ -219,19 +219,19 @@ fn get_destination(
let private_route = if let Some(prid) = get_route_id(rss.clone(), false, true)(text) let private_route = if let Some(prid) = get_route_id(rss.clone(), false, true)(text)
{ {
let Some(private_route) = rss.best_remote_private_route(&prid) else { let Some(private_route) = rss.best_remote_private_route(&prid) else {
return None; return None;
}; };
private_route private_route
} else { } else {
let mut dc = DEBUG_CACHE.lock(); let mut dc = DEBUG_CACHE.lock();
let n = get_number(text)?; let n = get_number(text)?;
let prid = dc.imported_routes.get(n)?.clone(); let prid = dc.imported_routes.get(n)?.clone();
let Some(private_route) = rss.best_remote_private_route(&prid) else { let Some(private_route) = rss.best_remote_private_route(&prid) else {
// Remove imported route // Remove imported route
dc.imported_routes.remove(n); dc.imported_routes.remove(n);
info!("removed dead imported route {}", n); info!("removed dead imported route {}", n);
return None; return None;
}; };
private_route private_route
}; };

3
veilid-flutter/rust/src/lib.rs
View File

@ -1,3 +1,6 @@
#![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)]
#![recursion_limit = "256"] #![recursion_limit = "256"]
mod dart_ffi; mod dart_ffi;

1
veilid-server/src/main.rs
View File

@ -1,5 +1,6 @@
#![forbid(unsafe_code)] #![forbid(unsafe_code)]
#![deny(clippy::all)] #![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)] #![deny(unused_must_use)]
#![recursion_limit = "256"] #![recursion_limit = "256"]

6
veilid-tools/src/assembly_buffer.rs
View File

@ -430,3 +430,9 @@ impl AssemblyBuffer {
Ok(NetworkResult::value(())) Ok(NetworkResult::value(()))
} }
} }
impl Default for AssemblyBuffer {
fn default() -> Self {
Self::new()
}
}

14
veilid-tools/src/async_tag_lock.rs
View File

@ -91,6 +91,11 @@ where
} }
} }
pub fn is_empty(&self) -> bool {
let inner = self.inner.lock();
inner.table.is_empty()
}
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
let inner = self.inner.lock(); let inner = self.inner.lock();
inner.table.len() inner.table.len()
@ -154,3 +159,12 @@ where
Some(AsyncTagLockGuard::new(self.clone(), tag, guard)) Some(AsyncTagLockGuard::new(self.clone(), tag, guard))
} }
} }
impl<T> Default for AsyncTagLockTable<T>
where
T: Hash + Eq + Clone + Debug,
{
fn default() -> Self {
Self::new()
}
}

3
veilid-tools/src/lib.rs
View File

@ -20,6 +20,9 @@
//! * `rt-async-std` - Uses `async-std` as the async runtime //! * `rt-async-std` - Uses `async-std` as the async runtime
//! * `rt-wasm-bindgen` - When building for the `wasm32` architecture, use this to enable `wasm-bindgen-futures` as the async runtime //! * `rt-wasm-bindgen` - When building for the `wasm32` architecture, use this to enable `wasm-bindgen-futures` as the async runtime
//! //!
#![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)]
// pub mod bump_port; // pub mod bump_port;
pub mod assembly_buffer; pub mod assembly_buffer;

47
veilid-tools/src/timestamp.rs
View File

@ -68,29 +68,32 @@ cfg_if! {
let show_month = show_year || now.month() != date.month(); let show_month = show_year || now.month() != date.month();
let show_date = show_month || now.day() != date.day(); let show_date = show_month || now.day() != date.day();
let s_year = if show_year {
format!("{:04}/",date.year())
} else {
"".to_owned()
};
let s_month = if show_month {
format!("{:02}/",date.month())
} else {
"".to_owned()
};
let s_date = if show_date {
format!("{:02}-",date.day())
} else {
"".to_owned()
};
let s_time = format!("{:02}:{:02}:{:02}.{:04}",
date.hour(),
date.minute(),
date.second(),
date.nanosecond()/1_000_000
);
format!("{}{}{}{}", format!("{}{}{}{}",
if show_year { s_year,
format!("{:04}/",date.year()) s_month,
} else { s_date,
"".to_owned() s_time)
},
if show_month {
format!("{:02}/",date.month())
} else {
"".to_owned()
},
if show_date {
format!("{:02}-",date.day())
} else {
"".to_owned()
},
format!("{:02}:{:02}:{:02}.{:04}",
date.hour(),
date.minute(),
date.second(),
date.nanosecond()/1_000_000
))
} }
} }
} }

10
veilid-tools/src/tools.rs
View File

@ -242,8 +242,10 @@ pub fn compatible_unspecified_socket_addr(socket_addr: &SocketAddr) -> SocketAdd
pub fn listen_address_to_socket_addrs(listen_address: &str) -> Result<Vec<SocketAddr>, String> { pub fn listen_address_to_socket_addrs(listen_address: &str) -> Result<Vec<SocketAddr>, String> {
// If no address is specified, but the port is, use ipv4 and ipv6 unspecified // If no address is specified, but the port is, use ipv4 and ipv6 unspecified
// If the address is specified, only use the specified port and fail otherwise // If the address is specified, only use the specified port and fail otherwise
let ip_addrs = [IpAddr::V4(Ipv4Addr::UNSPECIFIED), let ip_addrs = [
IpAddr::V6(Ipv6Addr::UNSPECIFIED)]; IpAddr::V4(Ipv4Addr::UNSPECIFIED),
IpAddr::V6(Ipv6Addr::UNSPECIFIED),
];
Ok(if let Some(portstr) = listen_address.strip_prefix(':') { Ok(if let Some(portstr) = listen_address.strip_prefix(':') {
let port = portstr let port = portstr
@ -333,6 +335,8 @@ cfg_if::cfg_if! {
#[repr(C, align(8))] #[repr(C, align(8))]
struct AlignToEight([u8; 8]); struct AlignToEight([u8; 8]);
/// # Safety
/// Ensure you immediately initialize this vector as it could contain sensitive data
pub unsafe fn aligned_8_u8_vec_uninit(n_bytes: usize) -> Vec<u8> { pub unsafe fn aligned_8_u8_vec_uninit(n_bytes: usize) -> Vec<u8> {
let n_units = (n_bytes + mem::size_of::<AlignToEight>() - 1) / mem::size_of::<AlignToEight>(); let n_units = (n_bytes + mem::size_of::<AlignToEight>() - 1) / mem::size_of::<AlignToEight>();
let mut aligned: Vec<AlignToEight> = Vec::with_capacity(n_units); let mut aligned: Vec<AlignToEight> = Vec::with_capacity(n_units);
@ -347,6 +351,8 @@ pub unsafe fn aligned_8_u8_vec_uninit(n_bytes: usize) -> Vec<u8> {
) )
} }
/// # Safety
/// Ensure you immediately initialize this vector as it could contain sensitive data
pub unsafe fn unaligned_u8_vec_uninit(n_bytes: usize) -> Vec<u8> { pub unsafe fn unaligned_u8_vec_uninit(n_bytes: usize) -> Vec<u8> {
let mut unaligned: Vec<u8> = Vec::with_capacity(n_bytes); let mut unaligned: Vec<u8> = Vec::with_capacity(n_bytes);
let ptr = unaligned.as_mut_ptr(); let ptr = unaligned.as_mut_ptr();

117
veilid-wasm/src/lib.rs
View File

@ -1,5 +1,7 @@
// wasm-bindgen and clippy don't play well together yet // wasm-bindgen and clippy don't play well together yet
#![allow(clippy::all)] #![deny(clippy::all)]
#![allow(clippy::comparison_chain, clippy::upper_case_acronyms)]
#![deny(unused_must_use)]
#![cfg(target_arch = "wasm32")] #![cfg(target_arch = "wasm32")]
#![no_std] #![no_std]
@ -363,7 +365,10 @@ pub fn routing_context_with_custom_privacy(id: u32, safety_selection: String) ->
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return 0; return 0;
}; };
let Ok(routing_context) = routing_context.clone().with_custom_privacy(safety_selection) else { let Ok(routing_context) = routing_context
.clone()
.with_custom_privacy(safety_selection)
else {
return 0; return 0;
}; };
let new_id = add_routing_context(routing_context); let new_id = add_routing_context(routing_context);
@ -392,7 +397,11 @@ pub fn routing_context_app_call(id: u32, target_string: String, request: String)
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_app_call", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_app_call",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -414,7 +423,11 @@ pub fn routing_context_app_message(id: u32, target_string: String, message: Stri
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_app_message", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_app_message",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -439,7 +452,11 @@ pub fn routing_context_create_dht_record(id: u32, schema: String, kind: u32) ->
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_create_dht_record", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_create_dht_record",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -460,7 +477,11 @@ pub fn routing_context_open_dht_record(id: u32, key: String, writer: Option<Stri
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_open_dht_record", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_open_dht_record",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -476,7 +497,11 @@ pub fn routing_context_close_dht_record(id: u32, key: String) -> Promise {
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_close_dht_record", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_close_dht_record",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -492,7 +517,11 @@ pub fn routing_context_delete_dht_record(id: u32, key: String) -> Promise {
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_delete_dht_record", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_delete_dht_record",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -513,7 +542,11 @@ pub fn routing_context_get_dht_value(
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_get_dht_value", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_get_dht_value",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -535,7 +568,11 @@ pub fn routing_context_set_dht_value(id: u32, key: String, subkey: u32, data: St
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_set_dht_value", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_set_dht_value",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -561,7 +598,11 @@ pub fn routing_context_watch_dht_values(
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_watch_dht_values", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_watch_dht_values",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -582,7 +623,11 @@ pub fn routing_context_cancel_dht_watch(id: u32, key: String, subkeys: String) -
let routing_context = { let routing_context = {
let rc = (*ROUTING_CONTEXTS).borrow(); let rc = (*ROUTING_CONTEXTS).borrow();
let Some(routing_context) = rc.get(&id) else { let Some(routing_context) = rc.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_cancel_dht_watch", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"routing_context_cancel_dht_watch",
"id",
id,
));
}; };
routing_context.clone() routing_context.clone()
}; };
@ -730,7 +775,11 @@ pub fn table_db_get_keys(id: u32, col: u32) -> Promise {
let table_db = { let table_db = {
let table_dbs = (*TABLE_DBS).borrow(); let table_dbs = (*TABLE_DBS).borrow();
let Some(table_db) = table_dbs.get(&id) else { let Some(table_db) = table_dbs.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_store", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_store",
"id",
id,
));
}; };
table_db.clone() table_db.clone()
}; };
@ -780,7 +829,11 @@ pub fn table_db_transaction_commit(id: u32) -> Promise {
let tdbt = { let tdbt = {
let tdbts = (*TABLE_DB_TRANSACTIONS).borrow(); let tdbts = (*TABLE_DB_TRANSACTIONS).borrow();
let Some(tdbt) = tdbts.get(&id) else { let Some(tdbt) = tdbts.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_transaction_commit", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_transaction_commit",
"id",
id,
));
}; };
tdbt.clone() tdbt.clone()
}; };
@ -796,7 +849,11 @@ pub fn table_db_transaction_rollback(id: u32) -> Promise {
let tdbt = { let tdbt = {
let tdbts = (*TABLE_DB_TRANSACTIONS).borrow(); let tdbts = (*TABLE_DB_TRANSACTIONS).borrow();
let Some(tdbt) = tdbts.get(&id) else { let Some(tdbt) = tdbts.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_transaction_rollback", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_transaction_rollback",
"id",
id,
));
}; };
tdbt.clone() tdbt.clone()
}; };
@ -818,7 +875,11 @@ pub fn table_db_transaction_store(id: u32, col: u32, key: String, value: String)
let tdbt = { let tdbt = {
let tdbts = (*TABLE_DB_TRANSACTIONS).borrow(); let tdbts = (*TABLE_DB_TRANSACTIONS).borrow();
let Some(tdbt) = tdbts.get(&id) else { let Some(tdbt) = tdbts.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_transaction_store", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_transaction_store",
"id",
id,
));
}; };
tdbt.clone() tdbt.clone()
}; };
@ -837,7 +898,11 @@ pub fn table_db_transaction_delete(id: u32, col: u32, key: String) -> Promise {
let tdbt = { let tdbt = {
let tdbts = (*TABLE_DB_TRANSACTIONS).borrow(); let tdbts = (*TABLE_DB_TRANSACTIONS).borrow();
let Some(tdbt) = tdbts.get(&id) else { let Some(tdbt) = tdbts.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_transaction_delete", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_transaction_delete",
"id",
id,
));
}; };
tdbt.clone() tdbt.clone()
}; };
@ -859,7 +924,11 @@ pub fn table_db_store(id: u32, col: u32, key: String, value: String) -> Promise
let table_db = { let table_db = {
let table_dbs = (*TABLE_DBS).borrow(); let table_dbs = (*TABLE_DBS).borrow();
let Some(table_db) = table_dbs.get(&id) else { let Some(table_db) = table_dbs.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_store", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_store",
"id",
id,
));
}; };
table_db.clone() table_db.clone()
}; };
@ -878,7 +947,11 @@ pub fn table_db_load(id: u32, col: u32, key: String) -> Promise {
let table_db = { let table_db = {
let table_dbs = (*TABLE_DBS).borrow(); let table_dbs = (*TABLE_DBS).borrow();
let Some(table_db) = table_dbs.get(&id) else { let Some(table_db) = table_dbs.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_load", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_load",
"id",
id,
));
}; };
table_db.clone() table_db.clone()
}; };
@ -898,7 +971,11 @@ pub fn table_db_delete(id: u32, col: u32, key: String) -> Promise {
let table_db = { let table_db = {
let table_dbs = (*TABLE_DBS).borrow(); let table_dbs = (*TABLE_DBS).borrow();
let Some(table_db) = table_dbs.get(&id) else { let Some(table_db) = table_dbs.get(&id) else {
return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("table_db_delete", "id", id)); return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument(
"table_db_delete",
"id",
id,
));
}; };
table_db.clone() table_db.clone()
}; };