liz/veilid
1
0
Fork 0
Code Pull Requests Packages Releases Activity

checkpoint

Browse Source
This commit is contained in:
John Smith
2022-04-08 10:17:09 -04:00
parent f7873aba88
commit ddb74d993f
13 changed files with 263 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
veilid-core/src/rpc_processor/coders/mod.rs
View File

@@ -3,6 +3,7 @@ mod dial_info;
mod network_class;
mod node_dial_info;
mod node_info;
mod node_status;
mod nonce;
mod peer_info;
mod private_safety_route;
@@ -15,6 +16,7 @@ pub use dial_info::*;
pub use network_class::*;
pub use node_dial_info::*;
pub use node_info::*;
pub use node_status::*;
pub use nonce::*;
pub use peer_info::*;
pub use private_safety_route::*;

82
veilid-core/src/rpc_processor/coders/node_info.rs
View File

@@ -6,27 +6,77 @@ pub fn encode_node_info(
builder: &mut veilid_capnp::node_info::Builder,
) -> Result<(), RPCError> {
builder.set_network_class(encode_network_class(node_info.network_class));
builder.set_will_route(node_info.will_route);
builder.set_will_tunnel(node_info.will_tunnel);
builder.set_will_signal(node_info.will_signal);
builder.set_will_relay(node_info.will_relay);
builder.set_will_validate_dial_info(node_info.will_validate_dial_info);
let mut dil_builder = builder.reborrow().init_dial_info_list(
node_info
.dial_infos
.len()
.try_into()
.map_err(map_error_protocol!("too many dial infos in node info"))?,
);
for idx in 0..node_info.dial_infos.len() {
let mut di_builder = dil_builder.reborrow().get(idx as u32);
encode_dial_info(&node_info.dial_infos[idx], &mut di_builder)?;
}
let mut rdil_builder = builder.reborrow().init_relay_dial_info_list(
node_info
.relay_dial_infos
.len()
.try_into()
.map_err(map_error_protocol!(
"too many relay dial infos in node info"
))?,
);
for idx in 0..node_info.relay_dial_infos.len() {
let mut rdi_builder = rdil_builder.reborrow().get(idx as u32);
encode_dial_info(&node_info.relay_dial_infos[idx], &mut rdi_builder)?;
}
Ok(())
}
pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<NodeInfo, RPCError> {
let network_class = decode_network_class(
reader
.reborrow()
.get_network_class()
.map_err(map_error_capnp_notinschema!())?,
);
let dil_reader = reader
.reborrow()
.get_dial_info_list()
.map_err(map_error_capnp_error!())?;
let mut dial_infos = Vec::<DialInfo>::with_capacity(
dil_reader
.len()
.try_into()
.map_err(map_error_protocol!("too many dial infos"))?,
);
for di in dil_reader.iter() {
dial_infos.push(decode_dial_info(&di)?)
}
let rdil_reader = reader
.reborrow()
.get_relay_dial_info_list()
.map_err(map_error_capnp_error!())?;
let mut relay_dial_infos = Vec::<DialInfo>::with_capacity(
rdil_reader
.len()
.try_into()
.map_err(map_error_protocol!("too many relay dial infos"))?,
);
for di in rdil_reader.iter() {
relay_dial_infos.push(decode_dial_info(&di)?)
}
Ok(NodeInfo {
network_class: decode_network_class(
reader
.reborrow()
.get_network_class()
.map_err(map_error_capnp_notinschema!())?,
),
will_route: reader.reborrow().get_will_route(),
will_tunnel: reader.reborrow().get_will_tunnel(),
will_signal: reader.reborrow().get_will_signal(),
will_relay: reader.reborrow().get_will_relay(),
will_validate_dial_info: reader.reborrow().get_will_validate_dial_info(),
network_class,
dial_infos,
relay_dial_infos,
})
}

27
veilid-core/src/rpc_processor/coders/node_status.rs Normal file
View File

@@ -0,0 +1,27 @@
use crate::*;
use rpc_processor::*;
pub fn encode_node_status(
node_status: &NodeStatus,
builder: &mut veilid_capnp::node_status::Builder,
) -> Result<(), RPCError> {
builder.set_will_route(node_status.will_route);
builder.set_will_tunnel(node_status.will_tunnel);
builder.set_will_signal(node_status.will_signal);
builder.set_will_relay(node_status.will_relay);
builder.set_will_validate_dial_info(node_status.will_validate_dial_info);
Ok(())
}
pub fn decode_node_status(
reader: &veilid_capnp::node_status::Reader,
) -> Result<NodeStatus, RPCError> {
Ok(NodeStatus {
will_route: reader.reborrow().get_will_route(),
will_tunnel: reader.reborrow().get_will_tunnel(),
will_signal: reader.reborrow().get_will_signal(),
will_relay: reader.reborrow().get_will_relay(),
will_validate_dial_info: reader.reborrow().get_will_validate_dial_info(),
})
}

32
veilid-core/src/rpc_processor/coders/peer_info.rs
View File

@@ -1,6 +1,4 @@
use crate::xx::*;
use crate::*;
use core::convert::TryInto;
use rpc_processor::*;
pub fn encode_peer_info(
@@ -10,18 +8,9 @@ pub fn encode_peer_info(
//
let mut nid_builder = builder.reborrow().init_node_id();
encode_public_key(&peer_info.node_id.key, &mut nid_builder)?;
let mut dil_builder = builder.reborrow().init_dial_info_list(
peer_info
.dial_infos
.len()
.try_into()
.map_err(map_error_protocol!("too many dial infos in peer info"))?,
);
let mut ni_builder = builder.reborrow().init_node_info();
encode_node_info(&peer_info.node_info, &mut ni_builder)?;
for idx in 0..peer_info.dial_infos.len() {
let mut di_builder = dil_builder.reborrow().get(idx as u32);
encode_dial_info(&peer_info.dial_infos[idx], &mut di_builder)?;
}
Ok(())
}
@@ -30,21 +19,14 @@ pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result<Peer
.reborrow()
.get_node_id()
.map_err(map_error_capnp_error!())?;
let dil_reader = reader
let ni_reader = reader
.reborrow()
.get_dial_info_list()
.get_node_info()
.map_err(map_error_capnp_error!())?;
let mut dial_infos = Vec::<DialInfo>::with_capacity(
dil_reader
.len()
.try_into()
.map_err(map_error_protocol!("too many dial infos"))?,
);
for di in dil_reader.iter() {
dial_infos.push(decode_dial_info(&di)?)
}
let node_info = decode_node_info(&ni_reader)?;
Ok(PeerInfo {
node_id: NodeId::new(decode_public_key(&nid_reader)),
dial_infos,
node_info,
})
}

18
veilid-core/src/rpc_processor/mod.rs
View File

@@ -30,7 +30,7 @@ pub enum Destination {
#[derive(Debug, Clone)]
pub enum RespondTo {
None,
Sender(Option<DialInfo>),
Sender(Option<NodeInfo>),
PrivateRoute(PrivateRoute),
}
@@ -43,9 +43,9 @@ impl RespondTo {
Self::None => {
builder.set_none(());
}
Self::Sender(Some(di)) => {
let mut di_builder = builder.reborrow().init_sender();
encode_dial_info(di, &mut di_builder)?;
Self::Sender(Some(ni)) => {
let mut ni_builder = builder.reborrow().init_sender();
encode_node_info(ni, &mut ni_builder)?;
}
Self::Sender(None) => {
builder.reborrow().init_sender();
@@ -220,7 +220,13 @@ impl RPCProcessor {
fn filter_peer_scope(&self, peer_info: &PeerInfo) -> bool {
// reject attempts to include non-public addresses in results
if self.default_peer_scope == PeerScope::Global {
for di in &peer_info.dial_infos {
for di in &peer_info.node_info.dial_infos {
if !di.is_global() {
// non-public address causes rejection
return false;
}
}
for di in &peer_info.node_info.relay_dial_infos {
if !di.is_global() {
// non-public address causes rejection
return false;
@@ -273,7 +279,7 @@ impl RPCProcessor {
if let Some(nr) = routing_table.lookup_node_ref(node_id) {
// ensure we have dial_info for the entry already,
// if not, we should do the find_node anyway
if !nr.operate(|e| e.dial_infos().is_empty()) {
if !nr.has_dial_info() {
return Ok(nr);
}
}