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

checkpoint

Browse Source
This commit is contained in:
John Smith 2022-07-04 17:58:26 -04:00
parent 6a87e32836
commit 9214bcf9a4
17 changed files with 276 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -390,12 +390,12 @@ impl RoutingTable {
} }
#[instrument(level = "trace", skip(self), ret, err)] #[instrument(level = "trace", skip(self), ret, err)]
pub fn register_find_node_answer(&self, fna: FindNodeAnswer) -> Result<Vec<NodeRef>, String> { pub fn register_find_node_answer(&self, peers: Vec<PeerInfo>) -> Result<Vec<NodeRef>, String> {
let node_id = self.node_id(); let node_id = self.node_id();
// register nodes we'd found // register nodes we'd found
let mut out = Vec::<NodeRef>::with_capacity(fna.peers.len()); let mut out = Vec::<NodeRef>::with_capacity(peers.len());
for p in fna.peers { for p in peers {
// if our own node if is in the list then ignore it, as we don't add ourselves to our own routing table // if our own node if is in the list then ignore it, as we don't add ourselves to our own routing table
if p.node_id.key == node_id { if p.node_id.key == node_id {
continue; continue;
@ -436,7 +436,7 @@ impl RoutingTable {
.map_err(logthru_rtab!())?; .map_err(logthru_rtab!())?;
// register nodes we'd found // register nodes we'd found
self.register_find_node_answer(res) self.register_find_node_answer(res.answer)
} }
#[instrument(level = "trace", skip(self), ret, err)] #[instrument(level = "trace", skip(self), ret, err)]

20
veilid-core/src/rpc_processor/coders/operations/answer.rs
View File

@ -67,52 +67,52 @@ impl RPCAnswerDetail {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?; let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader { let out = match which_reader {
veilid_capnp::answer::detail::StatusA(r) => { veilid_capnp::answer::detail::StatusA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationStatusA::decode(&op_reader)?; let out = RPCOperationStatusA::decode(&op_reader)?;
RPCAnswerDetail::StatusA(out) RPCAnswerDetail::StatusA(out)
} }
veilid_capnp::answer::detail::FindNodeA(r) => { veilid_capnp::answer::detail::FindNodeA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationFindNodeA::decode(&op_reader)?; let out = RPCOperationFindNodeA::decode(&op_reader)?;
RPCAnswerDetail::FindNodeA(out) RPCAnswerDetail::FindNodeA(out)
} }
veilid_capnp::answer::detail::GetValueA(r) => { veilid_capnp::answer::detail::GetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationGetValueA::decode(&op_reader)?; let out = RPCOperationGetValueA::decode(&op_reader)?;
RPCAnswerDetail::GetValueA(out) RPCAnswerDetail::GetValueA(out)
} }
veilid_capnp::answer::detail::SetValueA(r) => { veilid_capnp::answer::detail::SetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationSetValueA::decode(&op_reader)?; let out = RPCOperationSetValueA::decode(&op_reader)?;
RPCAnswerDetail::SetValueA(out) RPCAnswerDetail::SetValueA(out)
} }
veilid_capnp::answer::detail::WatchValueA(r) => { veilid_capnp::answer::detail::WatchValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationWatchValueA::decode(&op_reader)?; let out = RPCOperationWatchValueA::decode(&op_reader)?;
RPCAnswerDetail::WatchValueA(out) RPCAnswerDetail::WatchValueA(out)
} }
veilid_capnp::answer::detail::SupplyBlockA(r) => { veilid_capnp::answer::detail::SupplyBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationSupplyBlockA::decode(&op_reader)?; let out = RPCOperationSupplyBlockA::decode(&op_reader)?;
RPCAnswerDetail::SupplyBlockA(out) RPCAnswerDetail::SupplyBlockA(out)
} }
veilid_capnp::answer::detail::FindBlockA(r) => { veilid_capnp::answer::detail::FindBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationFindBlockA::decode(&op_reader)?; let out = RPCOperationFindBlockA::decode(&op_reader)?;
RPCAnswerDetail::FindBlockA(out) RPCAnswerDetail::FindBlockA(out)
} }
veilid_capnp::answer::detail::StartTunnelA(r) => { veilid_capnp::answer::detail::StartTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationStartTunnelA::decode(&op_reader)?; let out = RPCOperationStartTunnelA::decode(&op_reader)?;
RPCAnswerDetail::StartTunnelA(out) RPCAnswerDetail::StartTunnelA(out)
} }
veilid_capnp::answer::detail::CompleteTunnelA(r) => { veilid_capnp::answer::detail::CompleteTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCompleteTunnelA::decode(&op_reader)?; let out = RPCOperationCompleteTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CompleteTunnelA(out) RPCAnswerDetail::CompleteTunnelA(out)
} }
veilid_capnp::answer::detail::CancelTunnelA(r) => { veilid_capnp::answer::detail::CancelTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?; let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CancelTunnelA(out) RPCAnswerDetail::CancelTunnelA(out)
} }

6
veilid-core/src/rpc_processor/coders/operations/operation.rs
View File

@ -26,17 +26,17 @@ impl RPCOperationKind {
.map_err(map_error_capnp_notinschema!())?; .map_err(map_error_capnp_notinschema!())?;
let out = match which_reader { let out = match which_reader {
veilid_capnp::operation::kind::Which::Question(r) => { veilid_capnp::operation::kind::Which::Question(r) => {
let q_reader = r.map_err(map_error_capnp_notinschema!())?; let q_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCQuestion::decode(&q_reader, sender_node_id)?; let out = RPCQuestion::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Question(out) RPCOperationKind::Question(out)
} }
veilid_capnp::operation::kind::Which::Statement(r) => { veilid_capnp::operation::kind::Which::Statement(r) => {
let q_reader = r.map_err(map_error_capnp_notinschema!())?; let q_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCStatement::decode(&q_reader, sender_node_id)?; let out = RPCStatement::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Statement(out) RPCOperationKind::Statement(out)
} }
veilid_capnp::operation::kind::Which::Answer(r) => { veilid_capnp::operation::kind::Which::Answer(r) => {
let q_reader = r.map_err(map_error_capnp_notinschema!())?; let q_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCAnswer::decode(&q_reader)?; let out = RPCAnswer::decode(&q_reader)?;
RPCOperationKind::Answer(out) RPCOperationKind::Answer(out)
} }

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

@ -37,9 +37,7 @@ impl RPCOperationStatusA {
let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?; let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?;
let node_status = decode_node_status(&ns_reader)?; let node_status = decode_node_status(&ns_reader)?;
let si_reader = reader let si_reader = reader.get_sender_info().map_err(map_error_capnp_error!())?;
.get_sender_info()
.map_err(map_error_capnp_notinschema!())?;
let sender_info = decode_sender_info(&si_reader)?; let sender_info = decode_sender_info(&si_reader)?;
Ok(RPCOperationStatusA { Ok(RPCOperationStatusA {

20
veilid-core/src/rpc_processor/coders/operations/question.rs
View File

@ -80,52 +80,52 @@ impl RPCQuestionDetail {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?; let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader { let out = match which_reader {
veilid_capnp::question::detail::StatusQ(r) => { veilid_capnp::question::detail::StatusQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationStatusQ::decode(&op_reader)?; let out = RPCOperationStatusQ::decode(&op_reader)?;
RPCQuestionDetail::StatusQ(out) RPCQuestionDetail::StatusQ(out)
} }
veilid_capnp::question::detail::FindNodeQ(r) => { veilid_capnp::question::detail::FindNodeQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationFindNodeQ::decode(&op_reader)?; let out = RPCOperationFindNodeQ::decode(&op_reader)?;
RPCQuestionDetail::FindNodeQ(out) RPCQuestionDetail::FindNodeQ(out)
} }
veilid_capnp::question::detail::GetValueQ(r) => { veilid_capnp::question::detail::GetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationGetValueQ::decode(&op_reader)?; let out = RPCOperationGetValueQ::decode(&op_reader)?;
RPCQuestionDetail::GetValueQ(out) RPCQuestionDetail::GetValueQ(out)
} }
veilid_capnp::question::detail::SetValueQ(r) => { veilid_capnp::question::detail::SetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationSetValueQ::decode(&op_reader)?; let out = RPCOperationSetValueQ::decode(&op_reader)?;
RPCQuestionDetail::SetValueQ(out) RPCQuestionDetail::SetValueQ(out)
} }
veilid_capnp::question::detail::WatchValueQ(r) => { veilid_capnp::question::detail::WatchValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationWatchValueQ::decode(&op_reader)?; let out = RPCOperationWatchValueQ::decode(&op_reader)?;
RPCQuestionDetail::WatchValueQ(out) RPCQuestionDetail::WatchValueQ(out)
} }
veilid_capnp::question::detail::SupplyBlockQ(r) => { veilid_capnp::question::detail::SupplyBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationSupplyBlockQ::decode(&op_reader)?; let out = RPCOperationSupplyBlockQ::decode(&op_reader)?;
RPCQuestionDetail::SupplyBlockQ(out) RPCQuestionDetail::SupplyBlockQ(out)
} }
veilid_capnp::question::detail::FindBlockQ(r) => { veilid_capnp::question::detail::FindBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationFindBlockQ::decode(&op_reader)?; let out = RPCOperationFindBlockQ::decode(&op_reader)?;
RPCQuestionDetail::FindBlockQ(out) RPCQuestionDetail::FindBlockQ(out)
} }
veilid_capnp::question::detail::StartTunnelQ(r) => { veilid_capnp::question::detail::StartTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationStartTunnelQ::decode(&op_reader)?; let out = RPCOperationStartTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::StartTunnelQ(out) RPCQuestionDetail::StartTunnelQ(out)
} }
veilid_capnp::question::detail::CompleteTunnelQ(r) => { veilid_capnp::question::detail::CompleteTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?; let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CompleteTunnelQ(out) RPCQuestionDetail::CompleteTunnelQ(out)
} }
veilid_capnp::question::detail::CancelTunnelQ(r) => { veilid_capnp::question::detail::CancelTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?; let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CancelTunnelQ(out) RPCQuestionDetail::CancelTunnelQ(out)
} }

14
veilid-core/src/rpc_processor/coders/operations/statement.rs
View File

@ -14,7 +14,7 @@ impl RPCStatement {
pub fn detail(&self) -> &RPCStatementDetail { pub fn detail(&self) -> &RPCStatementDetail {
&self.detail &self.detail
} }
pub fn into_detail(self) -> RPCQuestionDetail { pub fn into_detail(self) -> RPCStatementDetail {
self.detail self.detail
} }
pub fn desc(&self) -> &'static str { pub fn desc(&self) -> &'static str {
@ -62,32 +62,32 @@ impl RPCStatementDetail {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?; let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader { let out = match which_reader {
veilid_capnp::statement::detail::ValidateDialInfo(r) => { veilid_capnp::statement::detail::ValidateDialInfo(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationValidateDialInfo::decode(&op_reader)?; let out = RPCOperationValidateDialInfo::decode(&op_reader)?;
RPCStatementDetail::ValidateDialInfo(out) RPCStatementDetail::ValidateDialInfo(out)
} }
veilid_capnp::statement::detail::Route(r) => { veilid_capnp::statement::detail::Route(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationRoute::decode(&op_reader)?; let out = RPCOperationRoute::decode(&op_reader)?;
RPCStatementDetail::Route(out) RPCStatementDetail::Route(out)
} }
veilid_capnp::statement::detail::NodeInfoUpdate(r) => { veilid_capnp::statement::detail::NodeInfoUpdate(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationNodeInfoUpdate::decode(&op_reader, sender_node_id)?; let out = RPCOperationNodeInfoUpdate::decode(&op_reader, sender_node_id)?;
RPCStatementDetail::NodeInfoUpdate(out) RPCStatementDetail::NodeInfoUpdate(out)
} }
veilid_capnp::statement::detail::ValueChanged(r) => { veilid_capnp::statement::detail::ValueChanged(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationValueChanged::decode(&op_reader)?; let out = RPCOperationValueChanged::decode(&op_reader)?;
RPCStatementDetail::ValueChanged(out) RPCStatementDetail::ValueChanged(out)
} }
veilid_capnp::statement::detail::Signal(r) => { veilid_capnp::statement::detail::Signal(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationSignal::decode(&op_reader)?; let out = RPCOperationSignal::decode(&op_reader)?;
RPCStatementDetail::Signal(out) RPCStatementDetail::Signal(out)
} }
veilid_capnp::statement::detail::ReturnReceipt(r) => { veilid_capnp::statement::detail::ReturnReceipt(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?; let op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?; let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCStatementDetail::ReturnReceipt(out) RPCStatementDetail::ReturnReceipt(out)
} }

10
veilid-core/src/rpc_processor/coders/private_safety_route.rs
View File

@ -21,6 +21,16 @@ pub struct PrivateRoute {
pub hops: Option<RouteHop>, pub hops: Option<RouteHop>,
} }
impl PrivateRoute {
pub fn new_stub(public_key: DHTKey) -> Self {
Self {
public_key,
hop_count: 0,
hops: None,
}
}
}
impl fmt::Display for PrivateRoute { impl fmt::Display for PrivateRoute {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!( write!(

6
veilid-core/src/rpc_processor/coders/tunnel.rs
View File

@ -74,9 +74,9 @@ pub fn decode_full_tunnel(
let id = reader.get_id(); let id = reader.get_id();
let timeout = reader.get_timeout(); let timeout = reader.get_timeout();
let l_reader = reader.get_local().map_err(map_error_capnp_error!())?; let l_reader = reader.get_local().map_err(map_error_capnp_error!())?;
let local = decode_tunnel_endpoint(&l_reader).map_err(map_error_capnp_error!())?; let local = decode_tunnel_endpoint(&l_reader)?;
let r_reader = reader.get_remote().map_err(map_error_capnp_error!())?; let r_reader = reader.get_remote().map_err(map_error_capnp_error!())?;
let remote = decode_tunnel_endpoint(&r_reader).map_err(map_error_capnp_error!())?; let remote = decode_tunnel_endpoint(&r_reader)?;
Ok(FullTunnel { Ok(FullTunnel {
id, id,
@ -103,7 +103,7 @@ pub fn decode_partial_tunnel(
let id = reader.get_id(); let id = reader.get_id();
let timeout = reader.get_timeout(); let timeout = reader.get_timeout();
let l_reader = reader.get_local().map_err(map_error_capnp_error!())?; let l_reader = reader.get_local().map_err(map_error_capnp_error!())?;
let local = decode_tunnel_endpoint(&l_reader).map_err(map_error_capnp_error!())?; let local = decode_tunnel_endpoint(&l_reader)?;
Ok(PartialTunnel { id, timeout, local }) Ok(PartialTunnel { id, timeout, local })
} }

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

@ -403,7 +403,7 @@ impl RPCProcessor {
#[instrument(level = "debug", skip(self, operation, safety_route_spec), err)] #[instrument(level = "debug", skip(self, operation, safety_route_spec), err)]
fn render_operation( fn render_operation(
&self, &self,
dest: &Destination, dest: Destination,
operation: &RPCOperation, operation: &RPCOperation,
safety_route_spec: Option<&SafetyRouteSpec>, safety_route_spec: Option<&SafetyRouteSpec>,
) -> Result<RenderedOperation, RPCError> { ) -> Result<RenderedOperation, RPCError> {
@ -420,7 +420,7 @@ impl RPCProcessor {
let out; // Envelope data let out; // Envelope data
// To where are we sending the request // To where are we sending the request
match &dest { match dest {
Destination::Direct(node_ref) | Destination::Relay(node_ref, _) => { Destination::Direct(node_ref) | Destination::Relay(node_ref, _) => {
// Send to a node without a private route // Send to a node without a private route
// -------------------------------------- // --------------------------------------
@ -449,8 +449,7 @@ impl RPCProcessor {
// No private route was specified for the request // No private route was specified for the request
// but we are using a safety route, so we must create an empty private route // but we are using a safety route, so we must create an empty private route
let mut pr_builder = ::capnp::message::Builder::new_default(); let mut pr_builder = ::capnp::message::Builder::new_default();
let private_route = let private_route = PrivateRoute::new_stub(node_id);
self.new_stub_private_route(node_id, &mut pr_builder)?;
let message_vec = builder_to_vec(msg_builder)?; let message_vec = builder_to_vec(msg_builder)?;
// first // first
@ -469,14 +468,6 @@ impl RPCProcessor {
Destination::PrivateRoute(private_route) => { Destination::PrivateRoute(private_route) => {
// Send to private route // Send to private route
// --------------------- // ---------------------
// Encode the private route
let mut pr_msg_builder = ::capnp::message::Builder::new_default();
let mut pr_builder =
pr_msg_builder.init_root::<veilid_capnp::private_route::Builder>();
encode_private_route(private_route, &mut pr_builder)?;
let pr_reader = pr_builder.into_reader();
// Reply with 'route' operation // Reply with 'route' operation
let message_vec = builder_to_vec(msg_builder)?; let message_vec = builder_to_vec(msg_builder)?;
out_node_id = match safety_route_spec { out_node_id = match safety_route_spec {
@ -487,7 +478,7 @@ impl RPCProcessor {
Some(rh) => rh.dial_info.node_id.key, Some(rh) => rh.dial_info.node_id.key,
_ => return Err(rpc_error_internal("private route has no hops")), _ => return Err(rpc_error_internal("private route has no hops")),
}; };
out = self.wrap_with_route(None, pr_reader, message_vec)?; out = self.wrap_with_route(None, private_route, message_vec)?;
out_node_id out_node_id
} }
Some(sr) => { Some(sr) => {
@ -500,7 +491,7 @@ impl RPCProcessor {
.dial_info .dial_info
.node_id .node_id
.key; .key;
out = self.wrap_with_route(Some(sr), pr_reader, message_vec)?; out = self.wrap_with_route(Some(sr), private_route, message_vec)?;
out_node_id out_node_id
} }
} }
@ -533,6 +524,10 @@ impl RPCProcessor {
) -> Result<WaitableReply, RPCError> { ) -> Result<WaitableReply, RPCError> {
// Wrap question in operation // Wrap question in operation
let operation = RPCOperation::new_question(question); let operation = RPCOperation::new_question(question);
let op_id = operation.op_id();
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "question", op_id, desc = operation.kind().desc(), ?dest);
// Produce rendered operation // Produce rendered operation
let RenderedOperation { let RenderedOperation {
@ -540,7 +535,7 @@ impl RPCProcessor {
out_node_id, out_node_id,
out_noderef, out_noderef,
hopcount, hopcount,
} = self.render_operation(&dest, &operation, safety_route_spec)?; } = self.render_operation(dest, &operation, safety_route_spec)?;
// Calculate answer timeout // Calculate answer timeout
// Timeout is number of hops times the timeout per hop // Timeout is number of hops times the timeout per hop
@ -561,12 +556,8 @@ impl RPCProcessor {
}; };
// Set up op id eventual // Set up op id eventual
let op_id = operation.op_id();
let eventual = self.add_op_id_waiter(op_id); let eventual = self.add_op_id_waiter(op_id);
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "question", op_id, desc = operation.kind().desc(), ?dest);
// Send question // Send question
let bytes = out.len() as u64; let bytes = out.len() as u64;
let send_ts = intf::get_timestamp(); let send_ts = intf::get_timestamp();
@ -614,13 +605,16 @@ impl RPCProcessor {
// Wrap statement in operation // Wrap statement in operation
let operation = RPCOperation::new_statement(statement); let operation = RPCOperation::new_statement(statement);
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "statement", op_id = operation.op_id(), desc = operation.kind().desc(), ?dest);
// Produce rendered operation // Produce rendered operation
let RenderedOperation { let RenderedOperation {
out, out,
out_node_id, out_node_id,
out_noderef, out_noderef,
hopcount, hopcount,
} = self.render_operation(&dest, &operation, safety_route_spec)?; } = self.render_operation(dest, &operation, safety_route_spec)?;
// Calculate answer timeout // Calculate answer timeout
// Timeout is number of hops times the timeout per hop // Timeout is number of hops times the timeout per hop
@ -640,9 +634,6 @@ impl RPCProcessor {
} }
}; };
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "statement", op_id = operation.op_id(), desc = operation.kind().desc(), ?dest);
// Send statement // Send statement
let bytes = out.len() as u64; let bytes = out.len() as u64;
let send_ts = intf::get_timestamp(); let send_ts = intf::get_timestamp();
@ -713,13 +704,16 @@ impl RPCProcessor {
// Extract destination from respond_to // Extract destination from respond_to
let dest = self.get_respond_to_destination(&request); let dest = self.get_respond_to_destination(&request);
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "answer", op_id = operation.op_id(), desc = operation.kind().desc(), ?dest);
// Produce rendered operation // Produce rendered operation
let RenderedOperation { let RenderedOperation {
out, out,
out_node_id, out_node_id,
out_noderef, out_noderef,
hopcount, hopcount,
} = self.render_operation(&dest, &operation, safety_route_spec)?; } = self.render_operation(dest, &operation, safety_route_spec)?;
// If we need to resolve the first hop, do it // If we need to resolve the first hop, do it
let node_ref = match out_noderef { let node_ref = match out_noderef {
@ -733,9 +727,6 @@ impl RPCProcessor {
} }
}; };
// Log rpc send
debug!(target: "rpc_message", dir = "send", kind = "answer", op_id = operation.op_id(), desc = operation.kind().desc(), ?dest);
// Send the reply // Send the reply
let bytes = out.len() as u64; let bytes = out.len() as u64;
let send_ts = intf::get_timestamp(); let send_ts = intf::get_timestamp();
@ -768,16 +759,18 @@ impl RPCProcessor {
&self, &self,
encoded_msg: RPCMessageEncoded, encoded_msg: RPCMessageEncoded,
) -> Result<(), RPCError> { ) -> Result<(), RPCError> {
// Make an operation reader // Decode the operation
let reader = capnp::message::Reader::new(encoded_msg.data, Default::default());
let sender_node_id = encoded_msg.header.envelope.get_sender_id(); let sender_node_id = encoded_msg.header.envelope.get_sender_id();
let operation = reader
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
// Decode the RPC message // Decode the RPC message
let operation = RPCOperation::decode(&operation, &sender_node_id)?; let operation = {
let reader = capnp::message::Reader::new(encoded_msg.data, Default::default());
let op_reader = reader
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
RPCOperation::decode(&op_reader, &sender_node_id)?
};
// Get the sender noderef, incorporating and 'sender node info' we have from a question // Get the sender noderef, incorporating and 'sender node info' we have from a question
let mut opt_sender_nr: Option<NodeRef> = None; let mut opt_sender_nr: Option<NodeRef> = None;

61
veilid-core/src/rpc_processor/private_route.rs
View File

@ -2,32 +2,14 @@ use super::*;
impl RPCProcessor { impl RPCProcessor {
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
pub(super) fn new_stub_private_route<'a, T>( fn compile_safety_route(
&self, &self,
dest_node_id: DHTKey, safety_route_spec: &SafetyRouteSpec,
builder: &'a mut ::capnp::message::Builder<T>, private_route: PrivateRoute,
) -> Result<veilid_capnp::private_route::Reader<'a>, RPCError> ) -> Result<SafetyRoute, RPCError> {
where
T: capnp::message::Allocator + 'a,
{
let mut pr = builder.init_root::<veilid_capnp::private_route::Builder>();
let mut pr_pk = pr.reborrow().init_public_key();
encode_public_key(&dest_node_id, &mut pr_pk)?;
pr.set_hop_count(0u8);
// leave firstHop as null
Ok(pr.into_reader())
}
fn encode_safety_route<'a>(
&self,
safety_route: &SafetyRouteSpec,
private_route: veilid_capnp::private_route::Reader<'a>,
builder: &'a mut veilid_capnp::safety_route::Builder<'a>,
) -> Result<(), RPCError> {
// Ensure the total hop count isn't too long for our config // Ensure the total hop count isn't too long for our config
let pr_hopcount = private_route.get_hop_count() as usize; let pr_hopcount = private_route.hop_count as usize;
let sr_hopcount = safety_route.hops.len(); let sr_hopcount = safety_route_spec.hops.len();
let hopcount = 1 + sr_hopcount + pr_hopcount; let hopcount = 1 + sr_hopcount + pr_hopcount;
if hopcount > self.inner.lock().max_route_hop_count { if hopcount > self.inner.lock().max_route_hop_count {
return Err(rpc_error_internal("hop count too long for route")); return Err(rpc_error_internal("hop count too long for route"));
@ -35,7 +17,7 @@ impl RPCProcessor {
// Build the safety route // Build the safety route
let mut sr_pk = builder.reborrow().init_public_key(); let mut sr_pk = builder.reborrow().init_public_key();
encode_public_key(&safety_route.public_key, &mut sr_pk)?; encode_public_key(&safety_route_spec.public_key, &mut sr_pk)?;
builder.set_hop_count( builder.set_hop_count(
u8::try_from(sr_hopcount) u8::try_from(sr_hopcount)
@ -78,7 +60,7 @@ impl RPCProcessor {
let mut rh_message = ::capnp::message::Builder::new_default(); let mut rh_message = ::capnp::message::Builder::new_default();
let mut rh_builder = rh_message.init_root::<veilid_capnp::route_hop::Builder>(); let mut rh_builder = rh_message.init_root::<veilid_capnp::route_hop::Builder>();
let mut di_builder = rh_builder.reborrow().init_dial_info(); let mut di_builder = rh_builder.reborrow().init_dial_info();
encode_node_dial_info(&safety_route.hops[h].dial_info, &mut di_builder)?; encode_node_dial_info(&safety_route_spec.hops[h].dial_info, &mut di_builder)?;
// RouteHopData // RouteHopData
let mut rhd_builder = rh_builder.init_next_hop(); let mut rhd_builder = rh_builder.init_next_hop();
// Add the nonce // Add the nonce
@ -88,8 +70,8 @@ impl RPCProcessor {
let dh_secret = self let dh_secret = self
.crypto .crypto
.cached_dh( .cached_dh(
&safety_route.hops[h].dial_info.node_id.key, &safety_route_spec.hops[h].dial_info.node_id.key,
&safety_route.secret_key, &safety_route_spec.secret_key,
) )
.map_err(map_error_internal!("dh failed"))?; .map_err(map_error_internal!("dh failed"))?;
let enc_msg_data = let enc_msg_data =
@ -114,8 +96,8 @@ impl RPCProcessor {
let dh_secret = self let dh_secret = self
.crypto .crypto
.cached_dh( .cached_dh(
&safety_route.hops[0].dial_info.node_id.key, &safety_route_spec.hops[0].dial_info.node_id.key,
&safety_route.secret_key, &safety_route_spec.secret_key,
) )
.map_err(map_error_internal!("dh failed"))?; .map_err(map_error_internal!("dh failed"))?;
let enc_msg_data = Crypto::encrypt_aead(blob_data.as_slice(), &nonce, &dh_secret, None) let enc_msg_data = Crypto::encrypt_aead(blob_data.as_slice(), &nonce, &dh_secret, None)
@ -128,14 +110,21 @@ impl RPCProcessor {
} }
// Wrap an operation inside a route // Wrap an operation inside a route
pub(super) fn wrap_with_route<'a>( pub(super) fn wrap_with_route(
&self, &self,
safety_route: Option<&SafetyRouteSpec>, safety_route: Option<&SafetyRouteSpec>,
private_route: veilid_capnp::private_route::Reader<'a>, private_route: PrivateRoute,
message_data: Vec<u8>, message_data: Vec<u8>,
) -> Result<Vec<u8>, RPCError> { ) -> Result<Vec<u8>, RPCError> {
// Encode the private route
let mut pr_msg_builder = ::capnp::message::Builder::new_default();
let mut pr_builder = pr_msg_builder.init_root::<veilid_capnp::private_route::Builder>();
encode_private_route(&private_route, &mut pr_builder)?;
let pr_reader = pr_builder.into_reader();
// Get stuff before we lock inner // Get stuff before we lock inner
let op_id = self.get_next_op_id(); let op_id = intf::get_random_u64();
// Encrypt routed operation // Encrypt routed operation
let nonce = Crypto::get_random_nonce(); let nonce = Crypto::get_random_nonce();
let pr_pk_reader = private_route let pr_pk_reader = private_route
@ -152,6 +141,12 @@ impl RPCProcessor {
.map_err(map_error_internal!("encryption failed"))?; .map_err(map_error_internal!("encryption failed"))?;
// Prepare route operation // Prepare route operation
let route = RPCOperationRoute {
safety_route: todo!(),
operation: todo!(),
};
let route_msg = { let route_msg = {
let mut route_msg = ::capnp::message::Builder::new_default(); let mut route_msg = ::capnp::message::Builder::new_default();
let mut route_operation = route_msg.init_root::<veilid_capnp::operation::Builder>(); let mut route_operation = route_msg.init_root::<veilid_capnp::operation::Builder>();

169
veilid-core/src/rpc_processor/rpc_find_node.rs
View File

@ -9,140 +9,75 @@ impl RPCProcessor {
key: DHTKey, key: DHTKey,
safety_route: Option<&SafetyRouteSpec>, safety_route: Option<&SafetyRouteSpec>,
respond_to: RespondTo, respond_to: RespondTo,
) -> Result<FindNodeAnswer, RPCError> { ) -> Result<Answer<Vec<PeerInfo>>, RPCError> {
let find_node_q_msg = { let find_node_q = RPCOperationFindNodeQ { node_id: key };
let mut find_node_q_msg = ::capnp::message::Builder::new_default(); let question = RPCQuestion::new(respond_to, RPCQuestionDetail::FindNodeQ(find_node_q));
let mut question = find_node_q_msg.init_root::<veilid_capnp::operation::Builder>();
question.set_op_id(self.get_next_op_id());
let mut respond_to_builder = question.reborrow().init_respond_to();
respond_to.encode(&mut respond_to_builder)?;
let detail = question.reborrow().init_detail();
let mut fnq = detail.init_find_node_q();
let mut node_id_builder = fnq.reborrow().init_node_id();
encode_public_key(&key, &mut node_id_builder)?;
find_node_q_msg.into_reader()
};
// Send the find_node request // Send the find_node request
let waitable_reply = self let waitable_reply = self.question(dest, question, safety_route).await?;
.request(dest, find_node_q_msg, safety_route)
.await?
.unwrap();
// Wait for reply // Wait for reply
let (rpcreader, latency) = self.wait_for_reply(waitable_reply).await?; let (msg, latency) = self.wait_for_reply(waitable_reply).await?;
let response_operation = rpcreader // Get the right answer type
.reader let find_node_a = match msg.operation.into_kind() {
.get_root::<veilid_capnp::operation::Reader>() RPCOperationKind::Answer(a) => match a.into_detail() {
.map_err(map_error_capnp_error!()) RPCAnswerDetail::FindNodeA(a) => a,
.map_err(logthru_rpc!())?; _ => return Err(rpc_error_invalid_format("not a find_node answer")),
let find_node_a = match response_operation },
.get_detail() _ => return Err(rpc_error_invalid_format("not an answer")),
.which()
.map_err(map_error_capnp_notinschema!())
.map_err(logthru_rpc!())?
{
veilid_capnp::operation::detail::FindNodeA(a) => {
a.map_err(map_error_internal!("Invalid FindNodeA"))?
}
_ => return Err(rpc_error_internal("Incorrect RPC answer for question")),
}; };
let peers_reader = find_node_a // Verify peers are in the correct peer scope
.get_peers() for peer_info in &find_node_a.peers {
.map_err(map_error_internal!("Missing peers"))?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
if !self.filter_peer_scope(&peer_info.signed_node_info.node_info) { if !self.filter_peer_scope(&peer_info.signed_node_info.node_info) {
return Err(rpc_error_invalid_format( return Err(rpc_error_invalid_format(
"find_node response has invalid peer scope", "find_node response has invalid peer scope",
)); ));
} }
peers.push(peer_info);
} }
let out = FindNodeAnswer { latency, peers }; Ok(Answer::new(latency, find_node_a.peers))
Ok(out)
} }
pub(crate) async fn process_find_node_q(&self, rpcreader: RPCMessage) -> Result<(), RPCError> { pub(crate) async fn process_find_node_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
// // Get the question
let reply_msg = { let find_node_q = match msg.operation.kind() {
let operation = rpcreader RPCOperationKind::Question(q) => match q.detail() {
.reader RPCQuestionDetail::FindNodeQ(q) => q,
.get_root::<veilid_capnp::operation::Reader>() _ => panic!("not a status question"),
.map_err(map_error_capnp_error!()) },
.map_err(logthru_rpc!())?; _ => panic!("not a question"),
// find_node must always want an answer
if !self.wants_answer(&operation)? {
return Err(rpc_error_invalid_format("find_node_q should want answer"));
}
// get findNodeQ reader
let fnq_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::FindNodeQ(Ok(x))) => x,
_ => panic!("invalid operation type in process_find_node_q"),
};
// get the node id we want to look up
let target_node_id = decode_public_key(
&fnq_reader
.get_node_id()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?,
);
// add node information for the requesting node to our routing table
let routing_table = self.routing_table();
// find N nodes closest to the target node in our routing table
let own_peer_info = routing_table.get_own_peer_info();
let own_peer_info_is_valid = own_peer_info.signed_node_info.is_valid();
let closest_nodes = routing_table.find_closest_nodes(
target_node_id,
// filter
Some(move |_k, v| {
RoutingTable::filter_has_valid_signed_node_info(v, own_peer_info_is_valid)
}),
// transform
move |k, v| RoutingTable::transform_to_peer_info(k, v, &own_peer_info),
);
log_rpc!(">>>> Returning {} closest peers", closest_nodes.len());
// Send find_node answer
let mut reply_msg = ::capnp::message::Builder::new_default();
let mut answer = reply_msg.init_root::<veilid_capnp::operation::Builder>();
answer.set_op_id(operation.get_op_id());
let mut respond_to = answer.reborrow().init_respond_to();
respond_to.set_none(());
let detail = answer.reborrow().init_detail();
let fna = detail.init_find_node_a();
let mut peers_builder = fna.init_peers(
closest_nodes
.len()
.try_into()
.map_err(map_error_internal!("invalid closest nodes list length"))?,
);
for (i, closest_node) in closest_nodes.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
encode_peer_info(closest_node, &mut pi_builder)?;
}
reply_msg.into_reader()
}; };
self.reply(rpcreader, reply_msg, None).await // add node information for the requesting node to our routing table
let routing_table = self.routing_table();
// find N nodes closest to the target node in our routing table
let own_peer_info = routing_table.get_own_peer_info();
let own_peer_info_is_valid = own_peer_info.signed_node_info.is_valid();
let closest_nodes = routing_table.find_closest_nodes(
find_node_q.node_id,
// filter
Some(move |_k, v| {
RoutingTable::filter_has_valid_signed_node_info(v, own_peer_info_is_valid)
}),
// transform
move |k, v| RoutingTable::transform_to_peer_info(k, v, &own_peer_info),
);
// Make status answer
let find_node_a = RPCOperationFindNodeA {
peers: closest_nodes,
};
// Send status answer
self.answer(
msg,
RPCAnswer::new(RPCAnswerDetail::FindNodeA(find_node_a)),
None,
)
.await
} }
} }

64
veilid-core/src/rpc_processor/rpc_node_info_update.rs
View File

@ -4,73 +4,41 @@ impl RPCProcessor {
// Sends a our node info to another node // Sends a our node info to another node
// Can be sent via all methods including relays and routes // Can be sent via all methods including relays and routes
pub async fn rpc_call_node_info_update( pub async fn rpc_call_node_info_update(
&self, self,
dest: Destination, dest: Destination,
safety_route: Option<&SafetyRouteSpec>, safety_route: Option<&SafetyRouteSpec>,
) -> Result<(), RPCError> { ) -> Result<(), RPCError> {
let sni_msg = { let signed_node_info = self.routing_table().get_own_signed_node_info();
let mut sni_msg = ::capnp::message::Builder::new_default(); let node_info_update = RPCOperationNodeInfoUpdate { signed_node_info };
let mut question = sni_msg.init_root::<veilid_capnp::operation::Builder>(); let statement = RPCStatement::new(RPCStatementDetail::NodeInfoUpdate(node_info_update));
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 // Send the node_info_update request
self.request(dest, sni_msg, safety_route).await?; self.statement(dest, statement, safety_route).await?;
Ok(()) Ok(())
} }
pub(crate) async fn process_node_info_update( pub(crate) async fn process_node_info_update(&self, msg: RPCMessage) -> Result<(), RPCError> {
&self, let sender_node_id = msg.header.envelope.get_sender_id();
rpcreader: RPCMessage,
) -> 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 // Get the statement
if self.wants_answer(&operation)? { let node_info_update = match msg.operation.into_kind() {
return Err(rpc_error_invalid_format( RPCOperationKind::Statement(s) => match s.into_detail() {
"node_info_update should not want answer", RPCStatementDetail::NodeInfoUpdate(s) => s,
)); _ => panic!("not a node info update"),
} },
_ => panic!("not a statement"),
// 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 // Update our routing table with signed node info
if !self.filter_peer_scope(&signed_node_info.node_info) { if !self.filter_peer_scope(&node_info_update.signed_node_info.node_info) {
return Err(rpc_error_invalid_format( return Err(rpc_error_invalid_format(
"node_info_update has invalid peer scope", "node_info_update has invalid peer scope",
)); ));
} }
let _ = self let _ = self
.routing_table() .routing_table()
.register_node_with_signed_node_info(sender_node_id, signed_node_info) .register_node_with_signed_node_info(sender_node_id, node_info_update.signed_node_info)
.map_err(RPCError::Internal)?; .map_err(RPCError::Internal)?;
Ok(()) Ok(())

66
veilid-core/src/rpc_processor/rpc_return_receipt.rs
View File

@ -4,72 +4,36 @@ impl RPCProcessor {
// Sends a unidirectional in-band return receipt // Sends a unidirectional in-band return receipt
// Can be sent via all methods including relays and routes // Can be sent via all methods including relays and routes
pub async fn rpc_call_return_receipt<D: AsRef<[u8]>>( pub async fn rpc_call_return_receipt<D: AsRef<[u8]>>(
&self, self,
dest: Destination, dest: Destination,
safety_route: Option<&SafetyRouteSpec>, safety_route: Option<&SafetyRouteSpec>,
receipt: D, receipt: D,
) -> Result<(), RPCError> { ) -> Result<(), RPCError> {
let receipt = receipt.as_ref(); let receipt = receipt.as_ref().to_vec();
let rr_msg = { let return_receipt = RPCOperationReturnReceipt { receipt };
let mut rr_msg = ::capnp::message::Builder::new_default(); let statement = RPCStatement::new(RPCStatementDetail::ReturnReceipt(return_receipt));
let mut question = rr_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 rr_builder = detail.init_return_receipt();
let r_builder = rr_builder.init_receipt(receipt.len().try_into().map_err(
map_error_protocol!("invalid receipt length in return receipt"),
)?);
r_builder.copy_from_slice(receipt);
rr_msg.into_reader() // Send the return_receipt request
}; self.statement(dest, statement, safety_route).await?;
// Send the return receipt request
self.request(dest, rr_msg, safety_route).await?;
Ok(()) Ok(())
} }
pub(crate) async fn process_return_receipt( pub(crate) async fn process_return_receipt(&self, msg: RPCMessage) -> Result<(), RPCError> {
&self, // Get the statement
rpcreader: RPCMessage, let RPCOperationReturnReceipt { receipt } = match msg.operation.into_kind() {
) -> Result<(), RPCError> { RPCOperationKind::Statement(s) => match s.into_detail() {
let receipt = { RPCStatementDetail::ReturnReceipt(s) => s,
let operation = rpcreader _ => panic!("not a return receipt"),
.reader },
.get_root::<veilid_capnp::operation::Reader>() _ => panic!("not a statement"),
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
// This should never want an answer
if self.wants_answer(&operation)? {
return Err(rpc_error_invalid_format(
"return receipt should not want answer",
));
}
// get returnReceipt reader
let rr_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::ReturnReceipt(Ok(x))) => x,
_ => panic!("invalid operation type in process_return_receipt"),
};
// Get receipt
rr_reader
.get_receipt()
.map_err(map_error_internal!(
"no valid receipt in process_return_receipt"
))?
.to_vec()
}; };
// Handle it // Handle it
let network_manager = self.network_manager(); let network_manager = self.network_manager();
network_manager network_manager
.handle_in_band_receipt(receipt, rpcreader.header.peer_noderef) .handle_in_band_receipt(receipt, msg.header.peer_noderef)
.await .await
.map_err(map_error_string!()) .map_err(map_error_string!())
} }

50
veilid-core/src/rpc_processor/rpc_signal.rs
View File

@ -4,57 +4,35 @@ impl RPCProcessor {
// Sends a unidirectional signal to a node // Sends a unidirectional signal to a node
// Can be sent via all methods including relays and routes // Can be sent via all methods including relays and routes
pub async fn rpc_call_signal( pub async fn rpc_call_signal(
&self, self,
dest: Destination, dest: Destination,
safety_route: Option<&SafetyRouteSpec>, safety_route: Option<&SafetyRouteSpec>,
signal_info: SignalInfo, signal_info: SignalInfo,
) -> Result<(), RPCError> { ) -> Result<(), RPCError> {
let sig_msg = { //let signed_node_info = self.routing_table().get_own_signed_node_info();
let mut sig_msg = ::capnp::message::Builder::new_default(); let signal = RPCOperationSignal { signal_info };
let mut question = sig_msg.init_root::<veilid_capnp::operation::Builder>(); let statement = RPCStatement::new(RPCStatementDetail::Signal(signal));
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 mut sig_builder = detail.init_signal();
encode_signal_info(&signal_info, &mut sig_builder)?;
sig_msg.into_reader()
};
// Send the signal request // Send the signal request
self.request(dest, sig_msg, safety_route).await?; self.statement(dest, statement, safety_route).await?;
Ok(()) Ok(())
} }
pub(crate) async fn process_signal(&self, rpcreader: RPCMessage) -> Result<(), RPCError> { pub(crate) async fn process_signal(&self, msg: RPCMessage) -> Result<(), RPCError> {
let signal_info = { // Get the statement
let operation = rpcreader let signal = match msg.operation.into_kind() {
.reader RPCOperationKind::Statement(s) => match s.into_detail() {
.get_root::<veilid_capnp::operation::Reader>() RPCStatementDetail::Signal(s) => s,
.map_err(map_error_capnp_error!()) _ => panic!("not a node info update"),
.map_err(logthru_rpc!())?; },
_ => panic!("not a statement"),
// This should never want an answer
if self.wants_answer(&operation)? {
return Err(rpc_error_invalid_format("signal should not want answer"));
}
// get signal reader
let sig_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::Signal(Ok(x))) => x,
_ => panic!("invalid operation type in process_signal"),
};
// Get signal info
decode_signal_info(&sig_reader)?
}; };
// Handle it // Handle it
let network_manager = self.network_manager(); let network_manager = self.network_manager();
network_manager network_manager
.handle_signal(signal_info) .handle_signal(signal.signal_info)
.await .await
.map_err(map_error_string!()) .map_err(map_error_string!())
} }

7
veilid-core/src/rpc_processor/rpc_status.rs
View File

@ -3,10 +3,7 @@ use super::*;
impl RPCProcessor { impl RPCProcessor {
// Send StatusQ RPC request, receive StatusA answer // Send StatusQ RPC request, receive StatusA answer
// Can be sent via relays, but not via routes // Can be sent via relays, but not via routes
pub async fn rpc_call_status( pub async fn rpc_call_status(self, peer: NodeRef) -> Result<Answer<SenderInfo>, RPCError> {
self,
peer: NodeRef,
) -> Result<Answer<RPCOperationStatusA>, RPCError> {
let node_status = self.network_manager().generate_node_status(); let node_status = self.network_manager().generate_node_status();
let status_q = RPCOperationStatusQ { node_status }; let status_q = RPCOperationStatusQ { node_status };
let respond_to = self.make_respond_to_sender(peer.clone()); let respond_to = self.make_respond_to_sender(peer.clone());
@ -56,7 +53,7 @@ impl RPCProcessor {
} }
} }
Ok(Answer::new(latency, status_a)) Ok(Answer::new(latency, status_a.sender_info))
} }
pub(crate) async fn process_status_q(&self, msg: RPCMessage) -> Result<(), RPCError> { pub(crate) async fn process_status_q(&self, msg: RPCMessage) -> Result<(), RPCError> {

119
veilid-core/src/rpc_processor/rpc_validate_dial_info.rs
View File

@ -3,7 +3,7 @@ use super::*;
impl RPCProcessor { impl RPCProcessor {
// Can only be sent directly, not via relays or routes // Can only be sent directly, not via relays or routes
pub async fn rpc_call_validate_dial_info( pub async fn rpc_call_validate_dial_info(
&self, self,
peer: NodeRef, peer: NodeRef,
dial_info: DialInfo, dial_info: DialInfo,
redirect: bool, redirect: bool,
@ -16,38 +16,24 @@ impl RPCProcessor {
.dht .dht
.validate_dial_info_receipt_time_ms, .validate_dial_info_receipt_time_ms,
); );
//
let (vdi_msg, eventual_value) = {
let mut vdi_msg = ::capnp::message::Builder::new_default();
let mut question = vdi_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 mut vdi_builder = detail.init_validate_dial_info();
// Generate receipt and waitable eventual so we can see if we get the receipt back // Generate receipt and waitable eventual so we can see if we get the receipt back
let (receipt, eventual_value) = network_manager let (receipt, eventual_value) = network_manager
.generate_single_shot_receipt(receipt_time, []) .generate_single_shot_receipt(receipt_time, [])
.map_err(map_error_string!())?; .map_err(map_error_string!())?;
vdi_builder.set_redirect(redirect); let validate_dial_info = RPCOperationValidateDialInfo {
let mut di_builder = vdi_builder.reborrow().init_dial_info(); dial_info,
encode_dial_info(&dial_info, &mut di_builder)?; receipt,
let r_builder = vdi_builder.init_receipt(receipt.len().try_into().map_err( redirect,
map_error_protocol!("invalid receipt length in validate dial info"),
)?);
r_builder.copy_from_slice(&receipt);
(vdi_msg.into_reader(), eventual_value)
}; };
let statement = RPCStatement::new(RPCStatementDetail::ValidateDialInfo(validate_dial_info));
// Send the validate_dial_info request // Send the validate_dial_info request
// This can only be sent directly, as relays can not validate dial info // This can only be sent directly, as relays can not validate dial info
self.request(Destination::Direct(peer), vdi_msg, None) self.statement(Destination::Direct(peer), statement, None)
.await?; .await?;
log_net!(debug "waiting for validate_dial_info receipt");
// Wait for receipt // Wait for receipt
match eventual_value.await.take_value().unwrap() { match eventual_value.await.take_value().unwrap() {
ReceiptEvent::ReturnedInBand { inbound_noderef: _ } => Err(rpc_error_internal( ReceiptEvent::ReturnedInBand { inbound_noderef: _ } => Err(rpc_error_internal(
@ -67,44 +53,18 @@ impl RPCProcessor {
} }
} }
pub(crate) async fn process_validate_dial_info( pub(crate) async fn process_validate_dial_info(&self, msg: RPCMessage) -> Result<(), RPCError> {
&self, // Get the statement
rpcreader: RPCMessage, let RPCOperationValidateDialInfo {
) -> Result<(), RPCError> { dial_info,
// receipt,
let (redirect, dial_info, receipt) = { redirect,
let operation = rpcreader } = match msg.operation.into_kind() {
.reader RPCOperationKind::Statement(s) => match s.into_detail() {
.get_root::<veilid_capnp::operation::Reader>() RPCStatementDetail::ValidateDialInfo(s) => s,
.map_err(map_error_capnp_error!()) _ => panic!("not a validate dial info"),
.map_err(logthru_rpc!())?; },
_ => panic!("not a statement"),
// This should never want an answer
if self.wants_answer(&operation)? {
return Err(rpc_error_invalid_format(
"validate dial info should not want answer",
));
}
// get validateDialInfo reader
let vdi_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::ValidateDialInfo(Ok(x))) => x,
_ => panic!("invalid operation type in process_validate_dial_info"),
};
// Parse out fields
let redirect = vdi_reader.get_redirect();
let dial_info = decode_dial_info(&vdi_reader.get_dial_info().map_err(
map_error_internal!("no valid dial info in process_validate_dial_info"),
)?)?;
let receipt = vdi_reader
.get_receipt()
.map_err(map_error_internal!(
"no valid receipt in process_validate_dial_info"
))?
.to_vec();
(redirect, dial_info, receipt)
}; };
// Redirect this request if we are asked to // Redirect this request if we are asked to
@ -115,19 +75,19 @@ impl RPCProcessor {
// an ipv6 address // an ipv6 address
let routing_table = self.routing_table(); let routing_table = self.routing_table();
let filter = DialInfoFilter::global().with_address_type(dial_info.address_type()); let filter = DialInfoFilter::global().with_address_type(dial_info.address_type());
let sender_id = rpcreader.header.envelope.get_sender_id(); let sender_id = msg.header.envelope.get_sender_id();
let node_count = { let node_count = {
let c = self.config.get(); let c = self.config.get();
c.network.dht.max_find_node_count as usize c.network.dht.max_find_node_count as usize
}; };
let mut peers = routing_table.find_fast_public_nodes_filtered(node_count, &filter); let peers = routing_table.find_fast_public_nodes_filtered(node_count, &filter);
if peers.is_empty() { if peers.is_empty() {
return Err(rpc_error_internal(format!( return Err(rpc_error_internal(format!(
"no peers matching filter '{:?}'", "no peers matching filter '{:?}'",
filter filter
))); )));
} }
for peer in &mut peers { for mut peer in peers {
// Ensure the peer is not the one asking for the validation // Ensure the peer is not the one asking for the validation
if peer.node_id() == sender_id { if peer.node_id() == sender_id {
continue; continue;
@ -166,26 +126,17 @@ impl RPCProcessor {
} }
// Make a copy of the request, without the redirect flag // Make a copy of the request, without the redirect flag
let vdi_msg_reader = { let validate_dial_info = RPCOperationValidateDialInfo {
let mut vdi_msg = ::capnp::message::Builder::new_default(); dial_info: dial_info.clone(),
let mut question = vdi_msg.init_root::<veilid_capnp::operation::Builder>(); receipt: receipt.clone(),
question.set_op_id(self.get_next_op_id()); redirect: false,
let mut respond_to = question.reborrow().init_respond_to();
respond_to.set_none(());
let detail = question.reborrow().init_detail();
let mut vdi_builder = detail.init_validate_dial_info();
vdi_builder.set_redirect(false);
let mut di_builder = vdi_builder.reborrow().init_dial_info();
encode_dial_info(&dial_info, &mut di_builder)?;
let r_builder = vdi_builder.init_receipt(receipt.len().try_into().map_err(
map_error_protocol!("invalid receipt length in process_validate_dial_info"),
)?);
r_builder.copy_from_slice(&receipt);
vdi_msg.into_reader()
}; };
let statement =
RPCStatement::new(RPCStatementDetail::ValidateDialInfo(validate_dial_info));
// Send the validate_dial_info request until we succeed // Send the validate_dial_info request
self.request(Destination::Direct(peer.clone()), vdi_msg_reader, None) // This can only be sent directly, as relays can not validate dial info
self.statement(Destination::Direct(peer), statement, None)
.await?; .await?;
} }
return Ok(()); return Ok(());

67
veilid-core/src/veilid_api/mod.rs
View File

@ -21,12 +21,11 @@ pub use intf::ProtectedStore;
pub use intf::TableStore; pub use intf::TableStore;
pub use network_manager::NetworkManager; pub use network_manager::NetworkManager;
pub use routing_table::RoutingTable; pub use routing_table::RoutingTable;
pub use rpc_processor::StatusAnswer; //pub use rpc_processor::RPCProcessor;
use core::fmt; use core::fmt;
use core_context::{api_shutdown, VeilidCoreContext}; use core_context::{api_shutdown, VeilidCoreContext};
use enumset::*; use enumset::*;
use rpc_processor::{RPCError, RPCProcessor};
use serde::*; use serde::*;
use xx::*; use xx::*;
@ -116,26 +115,26 @@ impl fmt::Display for VeilidAPIError {
} }
} }
fn convert_rpc_error(x: RPCError) -> VeilidAPIError { // fn convert_rpc_error(x: RPCError) -> VeilidAPIError {
match x { // match x {
RPCError::Timeout => VeilidAPIError::Timeout, // RPCError::Timeout => VeilidAPIError::Timeout,
RPCError::Unreachable(n) => VeilidAPIError::NodeNotFound { // RPCError::Unreachable(n) => VeilidAPIError::NodeNotFound {
node_id: NodeId::new(n), // node_id: NodeId::new(n),
}, // },
RPCError::Unimplemented(s) => VeilidAPIError::Unimplemented { message: s }, // RPCError::Unimplemented(s) => VeilidAPIError::Unimplemented { message: s },
RPCError::Internal(s) => VeilidAPIError::Internal { message: s }, // RPCError::Internal(s) => VeilidAPIError::Internal { message: s },
RPCError::Protocol(s) => VeilidAPIError::Internal { message: s }, // RPCError::Protocol(s) => VeilidAPIError::Internal { message: s },
RPCError::InvalidFormat(s) => VeilidAPIError::Internal { // RPCError::InvalidFormat(s) => VeilidAPIError::Internal {
message: format!("Invalid RPC format: {}", s), // message: format!("Invalid RPC format: {}", s),
}, // },
} // }
} // }
macro_rules! map_rpc_error { // macro_rules! map_rpc_error {
() => { // () => {
|x| convert_rpc_error(x) // |x| convert_rpc_error(x)
}; // };
} // }
macro_rules! parse_error { macro_rules! parse_error {
($msg:expr, $val:expr) => { ($msg:expr, $val:expr) => {
@ -1643,6 +1642,17 @@ pub struct PrivateRouteSpec {
pub hops: Vec<RouteHopSpec>, pub hops: Vec<RouteHopSpec>,
} }
impl PrivateRouteSpec {
pub fn new() -> Self {
let (pk, sk) = generate_secret();
PrivateRouteSpec {
public_key: pk,
secret_key: sk,
hops: Vec::new(),
}
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)] #[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct SafetyRouteSpec { pub struct SafetyRouteSpec {
pub public_key: DHTKey, pub public_key: DHTKey,
@ -1837,13 +1847,14 @@ impl VeilidAPI {
} }
Err(VeilidAPIError::NotInitialized) Err(VeilidAPIError::NotInitialized)
} }
pub fn rpc_processor(&self) -> Result<RPCProcessor, VeilidAPIError> {
let inner = self.inner.lock(); // pub fn rpc_processor(&self) -> Result<RPCProcessor, VeilidAPIError> {
if let Some(context) = &inner.context { // let inner = self.inner.lock();
return Ok(context.attachment_manager.network_manager().rpc_processor()); // if let Some(context) = &inner.context {
} // return Ok(context.attachment_manager.network_manager().rpc_processor());
Err(VeilidAPIError::NotInitialized) // }
} // Err(VeilidAPIError::NotInitialized)
// }
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// Attach/Detach // Attach/Detach