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

signed node info

Browse Source
This commit is contained in:
John Smith
2022-05-10 21:49:42 -04:00
parent 3b2f4d184f
commit 912869d329
14 changed files with 635 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,8 @@ mod protocol_set;
mod public_key;
mod sender_info;
mod signal_info;
mod signature;
mod signed_node_info;
mod socket_address;
pub use address::*;
@@ -30,4 +32,6 @@ pub use protocol_set::*;
pub use public_key::*;
pub use sender_info::*;
pub use signal_info::*;
pub use signature::*;
pub use signed_node_info::*;
pub use socket_address::*;

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

@@ -8,8 +8,8 @@ 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 ni_builder = builder.reborrow().init_node_info();
encode_node_info(&peer_info.node_info, &mut ni_builder)?;
let mut sni_builder = builder.reborrow().init_signed_node_info();
encode_signed_node_info(&peer_info.signed_node_info, &mut sni_builder)?;
Ok(())
}
@@ -22,14 +22,16 @@ pub fn decode_peer_info(
.reborrow()
.get_node_id()
.map_err(map_error_capnp_error!())?;
let ni_reader = reader
let sni_reader = reader
.reborrow()
.get_node_info()
.get_signed_node_info()
.map_err(map_error_capnp_error!())?;
let node_info = decode_node_info(&ni_reader, allow_relay_peer_info)?;
let node_id = NodeId::new(decode_public_key(&nid_reader));
let signed_node_info =
decode_signed_node_info(&sni_reader, &node_id.key, allow_relay_peer_info)?;
Ok(PeerInfo {
node_id: NodeId::new(decode_public_key(&nid_reader)),
node_info,
node_id,
signed_node_info,
})
}

60
veilid-core/src/rpc_processor/coders/signature.rs Normal file
View File

@@ -0,0 +1,60 @@
use crate::*;
use rpc_processor::*;
pub fn encode_signature(
sig: &DHTSignature,
builder: &mut veilid_capnp::ed25519_signature::Builder,
) {
if sig.valid {
panic!("don't encode invalid signatures");
}
let sig = &sig.bytes;
builder.set_u0(u64::from_be_bytes(
sig[0..8].try_into().expect("slice with incorrect length"),
));
builder.set_u1(u64::from_be_bytes(
sig[8..16].try_into().expect("slice with incorrect length"),
));
builder.set_u2(u64::from_be_bytes(
sig[16..24].try_into().expect("slice with incorrect length"),
));
builder.set_u3(u64::from_be_bytes(
sig[24..32].try_into().expect("slice with incorrect length"),
));
builder.set_u4(u64::from_be_bytes(
sig[32..40].try_into().expect("slice with incorrect length"),
));
builder.set_u5(u64::from_be_bytes(
sig[40..48].try_into().expect("slice with incorrect length"),
));
builder.set_u6(u64::from_be_bytes(
sig[48..56].try_into().expect("slice with incorrect length"),
));
builder.set_u7(u64::from_be_bytes(
sig[56..64].try_into().expect("slice with incorrect length"),
));
}
pub fn decode_signature(reader: &veilid_capnp::ed25519_signature::Reader) -> DHTSignature {
let u0 = reader.get_u0().to_be_bytes();
let u1 = reader.get_u1().to_be_bytes();
let u2 = reader.get_u2().to_be_bytes();
let u3 = reader.get_u3().to_be_bytes();
let u4 = reader.get_u4().to_be_bytes();
let u5 = reader.get_u5().to_be_bytes();
let u6 = reader.get_u6().to_be_bytes();
let u7 = reader.get_u7().to_be_bytes();
DHTSignature::new([
u0[0], u0[1], u0[2], u0[3], u0[4], u0[5], u0[6], u0[7], // u0
u1[0], u1[1], u1[2], u1[3], u1[4], u1[5], u1[6], u1[7], // u1
u2[0], u2[1], u2[2], u2[3], u2[4], u2[5], u2[6], u2[7], // u2
u3[0], u3[1], u3[2], u3[3], u3[4], u3[5], u3[6], u3[7], // u3
u4[0], u4[1], u4[2], u4[3], u4[4], u4[5], u4[6], u4[7], // u4
u5[0], u5[1], u5[2], u5[3], u5[4], u5[5], u5[6], u5[7], // u5
u6[0], u6[1], u6[2], u6[3], u6[4], u6[5], u6[6], u6[7], // u6
u7[0], u7[1], u7[2], u7[3], u7[4], u7[5], u7[6], u7[7], // u7
])
}

36
veilid-core/src/rpc_processor/coders/signed_node_info.rs Normal file
View File

@@ -0,0 +1,36 @@
use crate::*;
use rpc_processor::*;
pub fn encode_signed_node_info(
signed_node_info: &SignedNodeInfo,
builder: &mut veilid_capnp::signed_node_info::Builder,
) -> Result<(), RPCError> {
//
let mut ni_builder = builder.reborrow().init_node_info();
encode_node_info(&signed_node_info.node_info, &mut ni_builder)?;
let mut sig_builder = builder.reborrow().init_signature();
encode_signature(&signed_node_info.signature, &mut sig_builder);
Ok(())
}
pub fn decode_signed_node_info(
reader: &veilid_capnp::signed_node_info::Reader,
node_id: &DHTKey,
allow_relay_peer_info: bool,
) -> Result<SignedNodeInfo, RPCError> {
let ni_reader = reader
.reborrow()
.get_node_info()
.map_err(map_error_capnp_error!())?;
let node_info = decode_node_info(&ni_reader, allow_relay_peer_info)?;
let sig_reader = reader
.reborrow()
.get_signature()
.map_err(map_error_capnp_error!())?;
let signature = decode_signature(&sig_reader);
SignedNodeInfo::new(node_info, NodeId::new(*node_id), signature).map_err(map_error_string!())
}

25
veilid-core/src/rpc_processor/debug.rs
View File

@@ -125,20 +125,24 @@ impl RPCProcessor {
let respond_to_str = match respond_to {
veilid_capnp::operation::respond_to::None(_) => "(None)".to_owned(),
veilid_capnp::operation::respond_to::Sender(_) => "Sender".to_owned(),
veilid_capnp::operation::respond_to::SenderWithInfo(ni) => {
let ni_reader = match ni {
Ok(nir) => nir,
veilid_capnp::operation::respond_to::SenderWithInfo(sni) => {
let sni_reader = match sni {
Ok(snir) => snir,
Err(e) => {
return e.to_string();
}
};
let node_info = match decode_node_info(&ni_reader, true) {
let signed_node_info = match decode_signed_node_info(
&sni_reader,
&request_rpcreader.header.envelope.get_sender_id(),
true,
) {
Ok(ni) => ni,
Err(e) => {
return e.to_string();
}
};
format!("Sender({:?})", node_info)
format!("Sender({:?})", signed_node_info)
}
veilid_capnp::operation::respond_to::PrivateRoute(pr) => {
let pr_reader = match pr {
@@ -197,11 +201,11 @@ impl RPCProcessor {
detail: &veilid_capnp::operation::detail::WhichReader,
) -> String {
match detail {
veilid_capnp::operation::detail::InfoQ(_) => {
format!("InfoQ")
veilid_capnp::operation::detail::StatusQ(_) => {
format!("StatusQ")
}
veilid_capnp::operation::detail::InfoA(_) => {
format!("InfoA")
veilid_capnp::operation::detail::StatusA(_) => {
format!("StatusA")
}
veilid_capnp::operation::detail::ValidateDialInfo(_) => {
format!("ValidateDialInfo")
@@ -255,6 +259,9 @@ impl RPCProcessor {
veilid_capnp::operation::detail::Route(_) => {
format!("Route")
}
veilid_capnp::operation::detail::NodeInfoUpdate(_) => {
format!("NodeInfoUpdate")
}
veilid_capnp::operation::detail::GetValueQ(_) => {
format!("GetValueQ")
}

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

@@ -31,7 +31,7 @@ pub enum Destination {
#[derive(Debug, Clone)]
pub enum RespondTo {
None,
Sender(Option<NodeInfo>),
Sender(Option<SignedNodeInfo>),
PrivateRoute(PrivateRoute),
}
@@ -44,9 +44,9 @@ impl RespondTo {
Self::None => {
builder.set_none(());
}
Self::Sender(Some(ni)) => {
let mut ni_builder = builder.reborrow().init_sender_with_info();
encode_node_info(ni, &mut ni_builder)?;
Self::Sender(Some(sni)) => {
let mut sni_builder = builder.reborrow().init_sender_with_info();
encode_signed_node_info(sni, &mut sni_builder)?;
}
Self::Sender(None) => {
builder.reborrow().set_sender(());
@@ -130,7 +130,7 @@ struct WaitableReply {
/////////////////////////////////////////////////////////////////////
#[derive(Clone, Debug, Default)]
pub struct InfoAnswer {
pub struct StatusAnswer {
pub latency: u64,
pub node_status: NodeStatus,
pub sender_info: SenderInfo,
@@ -227,7 +227,7 @@ impl RPCProcessor {
}
}
if let Some(rpi) = &node_info.relay_peer_info {
for did in &rpi.node_info.dial_info_detail_list {
for did in &rpi.signed_node_info.node_info.dial_info_detail_list {
if !did.dial_info.is_global() {
// non-public address causes rejection
return false;
@@ -748,20 +748,21 @@ impl RPCProcessor {
}
}
fn get_respond_to_sender_node_info(
fn get_respond_to_sender_signed_node_info(
&self,
operation: &veilid_capnp::operation::Reader,
) -> Result<Option<NodeInfo>, RPCError> {
sender_node_id: &DHTKey,
) -> Result<Option<SignedNodeInfo>, RPCError> {
match operation
.get_respond_to()
.which()
.map_err(map_error_capnp_notinschema!())?
{
veilid_capnp::operation::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => {
Ok(Some(decode_node_info(&sender_ni_reader, true)?))
}
veilid_capnp::operation::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => Ok(Some(
decode_signed_node_info(&sender_ni_reader, sender_node_id, true)?,
)),
veilid_capnp::operation::respond_to::SenderWithInfo(Err(e)) => Err(rpc_error_protocol(
format!("invalid sender_with_info node info: {}", e),
format!("invalid sender_with_info signed node info: {}", e),
)),
veilid_capnp::operation::respond_to::None(_)
| veilid_capnp::operation::respond_to::Sender(_)
@@ -779,7 +780,7 @@ impl RPCProcessor {
SenderInfo { socket_address }
}
async fn process_info_q(&self, rpcreader: RPCMessageReader) -> Result<(), RPCError> {
async fn process_status_q(&self, rpcreader: RPCMessageReader) -> Result<(), RPCError> {
let peer_noderef = rpcreader.header.peer_noderef.clone();
let sender_info = self.generate_sender_info(peer_noderef).await;
@@ -795,10 +796,10 @@ impl RPCProcessor {
return Ok(());
}
// get InfoQ reader
// get StatusQ reader
let iq_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::InfoQ(Ok(x))) => x,
_ => panic!("invalid operation type in process_info_q"),
Ok(veilid_capnp::operation::detail::Which::StatusQ(Ok(x))) => x,
_ => panic!("invalid operation type in process_status_q"),
};
// Parse out fields
@@ -810,7 +811,7 @@ impl RPCProcessor {
// update node status for the requesting node to our routing table
if let Some(sender_nr) = rpcreader.opt_sender_nr.clone() {
// Update latest node status in routing table for the infoq sender
// Update latest node status in routing table for the statusq sender
sender_nr.operate(|e| {
e.update_node_status(node_status);
});
@@ -823,15 +824,15 @@ impl RPCProcessor {
let mut respond_to = answer.reborrow().init_respond_to();
respond_to.set_none(());
let detail = answer.reborrow().init_detail();
let mut info_a = detail.init_info_a();
let mut status_a = detail.init_status_a();
// Add node status
let node_status = self.network_manager().generate_node_status();
let mut nsb = info_a.reborrow().init_node_status();
let mut nsb = status_a.reborrow().init_node_status();
encode_node_status(&node_status, &mut nsb)?;
// Add sender info
let mut sib = info_a.reborrow().init_sender_info();
let mut sib = status_a.reborrow().init_sender_info();
encode_sender_info(&sender_info, &mut sib)?;
reply_msg.into_reader()
@@ -982,7 +983,7 @@ impl RPCProcessor {
let closest_nodes = routing_table.find_closest_nodes(
target_node_id,
// filter
None,
Some(Box::new(RoutingTable::filter_has_valid_signed_node_info)),
// transform
|e| RoutingTable::transform_to_peer_info(e, &own_peer_info),
);
@@ -995,8 +996,8 @@ impl RPCProcessor {
let mut respond_to = answer.reborrow().init_respond_to();
respond_to.set_none(());
let detail = answer.reborrow().init_detail();
let info_a = detail.init_find_node_a();
let mut peers_builder = info_a.init_peers(
let fna = detail.init_find_node_a();
let mut peers_builder = fna.init_peers(
closest_nodes
.len()
.try_into()
@@ -1017,6 +1018,46 @@ impl RPCProcessor {
Err(rpc_error_unimplemented("process_route"))
}
async fn process_node_info_update(&self, rpcreader: RPCMessageReader) -> Result<(), RPCError> {
//
let sender_node_id = rpcreader.header.envelope.get_sender_id();
let signed_node_info = {
let operation = rpcreader
.reader
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
// This should never want an answer
if self.wants_answer(&operation)? {
return Err(RPCError::InvalidFormat);
}
// get nodeInfoUpdate reader
let niumsg_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::NodeInfoUpdate(Ok(x))) => x,
_ => panic!("invalid operation type in process_node_info_update"),
};
// Parse out fields
let sni_reader = niumsg_reader
.get_signed_node_info()
.map_err(map_error_internal!("no valid signed node info"))?;
decode_signed_node_info(&sni_reader, &sender_node_id, true)?
};
// Update our routing table with signed node info
if !self.filter_peer_scope(&signed_node_info.node_info) {
return Err(RPCError::InvalidFormat);
}
let _ = self
.routing_table()
.register_node_with_signed_node_info(sender_node_id, signed_node_info)
.map_err(RPCError::Internal)?;
Ok(())
}
async fn process_get_value_q(&self, _rpcreader: RPCMessageReader) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_get_value_q"))
}
@@ -1139,6 +1180,7 @@ impl RPCProcessor {
//////////////////////////////////////////////////////////////////////
async fn process_rpc_message_version_0(&self, msg: RPCMessage) -> Result<(), RPCError> {
let reader = capnp::message::Reader::new(msg.data, Default::default());
let sender_node_id = msg.header.envelope.get_sender_id();
let mut opt_sender_nr: Option<NodeRef> = None;
let which = {
let operation = reader
@@ -1151,55 +1193,53 @@ impl RPCProcessor {
.which()
.map_err(map_error_capnp_notinschema!())?
{
veilid_capnp::operation::detail::InfoQ(_) => (0u32, true),
veilid_capnp::operation::detail::InfoA(_) => (1u32, false),
veilid_capnp::operation::detail::StatusQ(_) => (0u32, true),
veilid_capnp::operation::detail::StatusA(_) => (1u32, false),
veilid_capnp::operation::detail::ValidateDialInfo(_) => (2u32, true),
veilid_capnp::operation::detail::FindNodeQ(_) => (3u32, true),
veilid_capnp::operation::detail::FindNodeA(_) => (4u32, false),
veilid_capnp::operation::detail::Route(_) => (5u32, true),
veilid_capnp::operation::detail::GetValueQ(_) => (6u32, true),
veilid_capnp::operation::detail::GetValueA(_) => (7u32, false),
veilid_capnp::operation::detail::SetValueQ(_) => (8u32, true),
veilid_capnp::operation::detail::SetValueA(_) => (9u32, false),
veilid_capnp::operation::detail::WatchValueQ(_) => (10u32, true),
veilid_capnp::operation::detail::WatchValueA(_) => (11u32, false),
veilid_capnp::operation::detail::ValueChanged(_) => (12u32, true),
veilid_capnp::operation::detail::SupplyBlockQ(_) => (13u32, true),
veilid_capnp::operation::detail::SupplyBlockA(_) => (14u32, false),
veilid_capnp::operation::detail::FindBlockQ(_) => (15u32, true),
veilid_capnp::operation::detail::FindBlockA(_) => (16u32, false),
veilid_capnp::operation::detail::Signal(_) => (17u32, true),
veilid_capnp::operation::detail::ReturnReceipt(_) => (18u32, true),
veilid_capnp::operation::detail::StartTunnelQ(_) => (19u32, true),
veilid_capnp::operation::detail::StartTunnelA(_) => (20u32, false),
veilid_capnp::operation::detail::CompleteTunnelQ(_) => (21u32, true),
veilid_capnp::operation::detail::CompleteTunnelA(_) => (22u32, false),
veilid_capnp::operation::detail::CancelTunnelQ(_) => (23u32, true),
veilid_capnp::operation::detail::CancelTunnelA(_) => (24u32, false),
veilid_capnp::operation::detail::NodeInfoUpdate(_) => (6u32, true),
veilid_capnp::operation::detail::GetValueQ(_) => (7u32, true),
veilid_capnp::operation::detail::GetValueA(_) => (8u32, false),
veilid_capnp::operation::detail::SetValueQ(_) => (9u32, true),
veilid_capnp::operation::detail::SetValueA(_) => (10u32, false),
veilid_capnp::operation::detail::WatchValueQ(_) => (11u32, true),
veilid_capnp::operation::detail::WatchValueA(_) => (12u32, false),
veilid_capnp::operation::detail::ValueChanged(_) => (13u32, true),
veilid_capnp::operation::detail::SupplyBlockQ(_) => (14u32, true),
veilid_capnp::operation::detail::SupplyBlockA(_) => (15u32, false),
veilid_capnp::operation::detail::FindBlockQ(_) => (16u32, true),
veilid_capnp::operation::detail::FindBlockA(_) => (17u32, false),
veilid_capnp::operation::detail::Signal(_) => (18u32, true),
veilid_capnp::operation::detail::ReturnReceipt(_) => (19u32, true),
veilid_capnp::operation::detail::StartTunnelQ(_) => (20u32, true),
veilid_capnp::operation::detail::StartTunnelA(_) => (21u32, false),
veilid_capnp::operation::detail::CompleteTunnelQ(_) => (22u32, true),
veilid_capnp::operation::detail::CompleteTunnelA(_) => (23u32, false),
veilid_capnp::operation::detail::CancelTunnelQ(_) => (24u32, true),
veilid_capnp::operation::detail::CancelTunnelA(_) => (25u32, false),
};
// Accounting for questions we receive
if is_q {
// See if we have some Sender NodeInfo to incorporate
opt_sender_nr =
if let Some(sender_ni) = self.get_respond_to_sender_node_info(&operation)? {
// Sender NodeInfo was specified, update our routing table with it
if !self.filter_peer_scope(&sender_ni) {
return Err(RPCError::InvalidFormat);
}
let nr = self
.routing_table()
.register_node_with_node_info(
msg.header.envelope.get_sender_id(),
sender_ni,
)
.map_err(RPCError::Internal)?;
Some(nr)
} else {
// look up sender node, in case it's different than our peer due to relaying
self.routing_table()
.lookup_node_ref(msg.header.envelope.get_sender_id())
};
opt_sender_nr = if let Some(sender_ni) =
self.get_respond_to_sender_signed_node_info(&operation, &sender_node_id)?
{
// Sender NodeInfo was specified, update our routing table with it
if !self.filter_peer_scope(&sender_ni.node_info) {
return Err(RPCError::InvalidFormat);
}
let nr = self
.routing_table()
.register_node_with_signed_node_info(sender_node_id, sender_ni)
.map_err(RPCError::Internal)?;
Some(nr)
} else {
// look up sender node, in case it's different than our peer due to relaying
self.routing_table().lookup_node_ref(sender_node_id)
};
if let Some(sender_nr) = opt_sender_nr.clone() {
self.routing_table().stats_question_rcvd(
@@ -1220,31 +1260,32 @@ impl RPCProcessor {
};
match which {
0 => self.process_info_q(rpcreader).await, // InfoQ
1 => self.process_answer(rpcreader).await, // InfoA
0 => self.process_status_q(rpcreader).await, // StatusQ
1 => self.process_answer(rpcreader).await, // StatusA
2 => self.process_validate_dial_info(rpcreader).await, // ValidateDialInfo
3 => self.process_find_node_q(rpcreader).await, // FindNodeQ
4 => self.process_answer(rpcreader).await, // FindNodeA
5 => self.process_route(rpcreader).await, // Route
6 => self.process_get_value_q(rpcreader).await, // GetValueQ
7 => self.process_answer(rpcreader).await, // GetValueA
8 => self.process_set_value_q(rpcreader).await, // SetValueQ
9 => self.process_answer(rpcreader).await, // SetValueA
10 => self.process_watch_value_q(rpcreader).await, // WatchValueQ
11 => self.process_answer(rpcreader).await, // WatchValueA
12 => self.process_value_changed(rpcreader).await, // ValueChanged
13 => self.process_supply_block_q(rpcreader).await, // SupplyBlockQ
14 => self.process_answer(rpcreader).await, // SupplyBlockA
15 => self.process_find_block_q(rpcreader).await, // FindBlockQ
16 => self.process_answer(rpcreader).await, // FindBlockA
17 => self.process_signal(rpcreader).await, // SignalQ
18 => self.process_return_receipt(rpcreader).await, // ReturnReceipt
19 => self.process_start_tunnel_q(rpcreader).await, // StartTunnelQ
20 => self.process_answer(rpcreader).await, // StartTunnelA
21 => self.process_complete_tunnel_q(rpcreader).await, // CompleteTunnelQ
22 => self.process_answer(rpcreader).await, // CompleteTunnelA
23 => self.process_cancel_tunnel_q(rpcreader).await, // CancelTunnelQ
24 => self.process_answer(rpcreader).await, // CancelTunnelA
4 => self.process_answer(rpcreader).await, // FindNodeA
5 => self.process_route(rpcreader).await, // Route
6 => self.process_node_info_update(rpcreader).await, // NodeInfoUpdate
7 => self.process_get_value_q(rpcreader).await, // GetValueQ
8 => self.process_answer(rpcreader).await, // GetValueA
9 => self.process_set_value_q(rpcreader).await, // SetValueQ
10 => self.process_answer(rpcreader).await, // SetValueA
11 => self.process_watch_value_q(rpcreader).await, // WatchValueQ
12 => self.process_answer(rpcreader).await, // WatchValueA
13 => self.process_value_changed(rpcreader).await, // ValueChanged
14 => self.process_supply_block_q(rpcreader).await, // SupplyBlockQ
15 => self.process_answer(rpcreader).await, // SupplyBlockA
16 => self.process_find_block_q(rpcreader).await, // FindBlockQ
17 => self.process_answer(rpcreader).await, // FindBlockA
18 => self.process_signal(rpcreader).await, // SignalQ
19 => self.process_return_receipt(rpcreader).await, // ReturnReceipt
20 => self.process_start_tunnel_q(rpcreader).await, // StartTunnelQ
21 => self.process_answer(rpcreader).await, // StartTunnelA
22 => self.process_complete_tunnel_q(rpcreader).await, // CompleteTunnelQ
23 => self.process_answer(rpcreader).await, // CompleteTunnelA
24 => self.process_cancel_tunnel_q(rpcreader).await, // CancelTunnelQ
25 => self.process_answer(rpcreader).await, // CancelTunnelA
_ => panic!("must update rpc table"),
}
}
@@ -1347,38 +1388,43 @@ impl RPCProcessor {
// or None if the peer has seen our dial info before or our node info is not yet valid
// because of an unknown network class
pub fn make_respond_to_sender(&self, peer: NodeRef) -> RespondTo {
let our_node_info = self.routing_table().get_own_peer_info().node_info;
if peer.has_seen_our_node_info()
|| matches!(our_node_info.network_class, NetworkClass::Invalid)
|| matches!(
self.network_manager()
.get_network_class()
.unwrap_or(NetworkClass::Invalid),
NetworkClass::Invalid
)
{
RespondTo::Sender(None)
} else {
RespondTo::Sender(Some(our_node_info))
let our_sni = self.routing_table().get_own_signed_node_info();
RespondTo::Sender(Some(our_sni))
}
}
// Send InfoQ RPC request, receive InfoA answer
// Send StatusQ RPC request, receive StatusA answer
// Can be sent via relays, but not via routes
pub async fn rpc_call_info(self, peer: NodeRef) -> Result<InfoAnswer, RPCError> {
let info_q_msg = {
let mut info_q_msg = ::capnp::message::Builder::new_default();
let mut question = info_q_msg.init_root::<veilid_capnp::operation::Builder>();
pub async fn rpc_call_status(self, peer: NodeRef) -> Result<StatusAnswer, RPCError> {
let status_q_msg = {
let mut status_q_msg = ::capnp::message::Builder::new_default();
let mut question = status_q_msg.init_root::<veilid_capnp::operation::Builder>();
question.set_op_id(self.get_next_op_id());
let mut respond_to = question.reborrow().init_respond_to();
self.make_respond_to_sender(peer.clone())
.encode(&mut respond_to)?;
let detail = question.reborrow().init_detail();
let mut iqb = detail.init_info_q();
let mut node_status_builder = iqb.reborrow().init_node_status();
let mut sqb = detail.init_status_q();
let mut node_status_builder = sqb.reborrow().init_node_status();
let node_status = self.network_manager().generate_node_status();
encode_node_status(&node_status, &mut node_status_builder)?;
info_q_msg.into_reader()
status_q_msg.into_reader()
};
// Send the info request
let waitable_reply = self
.request(Destination::Direct(peer.clone()), info_q_msg, None)
.request(Destination::Direct(peer.clone()), status_q_msg, None)
.await?
.unwrap();
@@ -1394,30 +1440,30 @@ impl RPCProcessor {
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
let info_a = match response_operation
let status_a = match response_operation
.get_detail()
.which()
.map_err(map_error_capnp_notinschema!())
.map_err(logthru_rpc!())?
{
veilid_capnp::operation::detail::InfoA(a) => {
a.map_err(map_error_internal!("Invalid InfoA"))?
veilid_capnp::operation::detail::StatusA(a) => {
a.map_err(map_error_internal!("Invalid StatusA"))?
}
_ => return Err(rpc_error_internal("Incorrect RPC answer for question")),
};
// Decode node info
if !info_a.has_node_status() {
if !status_a.has_node_status() {
return Err(rpc_error_internal("Missing node status"));
}
let nsr = info_a
let nsr = status_a
.get_node_status()
.map_err(map_error_internal!("Broken node status"))?;
let node_status = decode_node_status(&nsr)?;
// Decode sender info
let sender_info = if info_a.has_sender_info() {
let sir = info_a
let sender_info = if status_a.has_sender_info() {
let sir = status_a
.get_sender_info()
.map_err(map_error_internal!("Broken sender info"))?;
decode_sender_info(&sir)?
@@ -1453,7 +1499,7 @@ impl RPCProcessor {
}
// Return the answer for anyone who may care
let out = InfoAnswer {
let out = StatusAnswer {
latency,
node_status,
sender_info,
@@ -1583,7 +1629,7 @@ impl RPCProcessor {
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
if !self.filter_peer_scope(&peer_info.node_info) {
if !self.filter_peer_scope(&peer_info.signed_node_info.node_info) {
return Err(RPCError::InvalidFormat);
}
@@ -1595,6 +1641,34 @@ impl RPCProcessor {
Ok(out)
}
// Sends a our node info to another node
// Can be sent via all methods including relays and routes
pub async fn rpc_call_node_info_update(
&self,
dest: Destination,
safety_route: Option<&SafetyRouteSpec>,
) -> Result<(), RPCError> {
let sni_msg = {
let mut sni_msg = ::capnp::message::Builder::new_default();
let mut question = sni_msg.init_root::<veilid_capnp::operation::Builder>();
question.set_op_id(self.get_next_op_id());
let mut respond_to = question.reborrow().init_respond_to();
respond_to.set_none(());
let detail = question.reborrow().init_detail();
let niu_builder = detail.init_node_info_update();
let mut sni_builder = niu_builder.init_signed_node_info();
let sni = self.routing_table().get_own_signed_node_info();
encode_signed_node_info(&sni, &mut sni_builder)?;
sni_msg.into_reader()
};
// Send the node_info_update request
self.request(dest, sni_msg, safety_route).await?;
Ok(())
}
// Sends a unidirectional signal to a node
// Can be sent via all methods including relays and routes
pub async fn rpc_call_signal(