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

refactor

Browse Source
This commit is contained in:
John Smith
2022-07-10 17:36:50 -04:00
parent cd0cd78e30
commit 7e0d7dad06
108 changed files with 1378 additions and 1535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
veilid-core/src/rpc_processor/coders/address.rs
+7 -1
View File
@@ -55,6 +55,12 @@ pub fn decode_address(reader: &veilid_capnp::address::Reader) -> Result<Address,
v6b2[1], v6b2[2], v6b2[3], v6b3[0], v6b3[1], v6b3[2], v6b3[3],
])))
}
_ => Err(rpc_error_protocol("invalid address type")),
Ok(veilid_capnp::address::Which::Ipv4(Err(_))) => {
Err(RPCError::protocol("invalid ipv4 address"))
}
Ok(veilid_capnp::address::Which::Ipv6(Err(_))) => {
Err(RPCError::protocol("invalid ipv6 address"))
}
Err(_) => Err(RPCError::protocol("invalid address type")),
}
}
veilid-core/src/rpc_processor/coders/block_id.rs
+5 -13
View File
@@ -23,27 +23,19 @@ pub fn encode_block_id(
builder: &mut veilid_capnp::b_l_a_k_e3_hash::Builder,
) -> Result<(), RPCError> {
if !key.valid {
return Err(rpc_error_protocol("invalid key"));
return Err(RPCError::protocol("invalid key"));
}
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[0..8].try_into().map_err(RPCError::internal)?,
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[8..16].try_into().map_err(RPCError::internal)?,
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[16..24].try_into().map_err(RPCError::internal)?,
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[24..32].try_into().map_err(RPCError::internal)?,
));
Ok(())
}
veilid-core/src/rpc_processor/coders/dial_info.rs
+25 -18
View File
@@ -4,44 +4,51 @@ use core::convert::TryInto;
use rpc_processor::*;
pub fn decode_dial_info(reader: &veilid_capnp::dial_info::Reader) -> Result<DialInfo, RPCError> {
match reader.reborrow().which() {
Ok(veilid_capnp::dial_info::Which::Udp(Ok(udp))) => {
match reader
.reborrow()
.which()
.map_err(RPCError::map_protocol("Missing dial info type"))?
{
veilid_capnp::dial_info::Which::Udp(udp) => {
let socket_address_reader = udp
.map_err(RPCError::protocol)?
.get_socket_address()
.map_err(map_error_protocol!("missing UDP socketAddress"))?;
.map_err(RPCError::map_protocol("missing UDP socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
Ok(DialInfo::udp(socket_address))
}
Ok(veilid_capnp::dial_info::Which::Tcp(Ok(tcp))) => {
veilid_capnp::dial_info::Which::Tcp(tcp) => {
let socket_address_reader = tcp
.map_err(RPCError::protocol)?
.get_socket_address()
.map_err(map_error_protocol!("missing TCP socketAddress"))?;
.map_err(RPCError::map_protocol("missing TCP socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
Ok(DialInfo::tcp(socket_address))
}
Ok(veilid_capnp::dial_info::Which::Ws(Ok(ws))) => {
veilid_capnp::dial_info::Which::Ws(ws) => {
let ws = ws.map_err(RPCError::protocol)?;
let socket_address_reader = ws
.get_socket_address()
.map_err(map_error_protocol!("missing WS socketAddress"))?;
.map_err(RPCError::map_protocol("missing WS socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
let request = ws
.get_request()
.map_err(map_error_protocol!("missing WS request"))?;
.map_err(RPCError::map_protocol("missing WS request"))?;
DialInfo::try_ws(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WS dial info"))
.map_err(RPCError::map_protocol("invalid WS dial info"))
}
Ok(veilid_capnp::dial_info::Which::Wss(Ok(wss))) => {
veilid_capnp::dial_info::Which::Wss(wss) => {
let wss = wss.map_err(RPCError::protocol)?;
let socket_address_reader = wss
.get_socket_address()
.map_err(map_error_protocol!("missing WSS socketAddress"))?;
.map_err(RPCError::map_protocol("missing WSS socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
let request = wss
.get_request()
.map_err(map_error_protocol!("missing WSS request"))?;
.map_err(RPCError::map_protocol("missing WSS request"))?;
DialInfo::try_wss(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WSS dial info"))
.map_err(RPCError::map_protocol("invalid WSS dial info"))
}
_ => Err(rpc_error_internal("invalid dial info type")),
}
}
@@ -72,13 +79,13 @@ pub fn encode_dial_info(
)?;
let request = dial_info
.request()
.ok_or_else(|| rpc_error_internal("no request for WS dialinfo"))?;
.ok_or_else(RPCError::else_internal("no request for WS dialinfo"))?;
let mut requestb = di_ws_builder.init_request(
request
.len()
.try_into()
.map_err(map_error_protocol!("request too long"))?,
.map_err(RPCError::map_protocol("request too long"))?,
);
requestb.push_str(request.as_str());
}
@@ -90,13 +97,13 @@ pub fn encode_dial_info(
)?;
let request = dial_info
.request()
.ok_or_else(|| rpc_error_internal("no request for WSS dialinfo"))?;
.ok_or_else(RPCError::else_internal("no request for WSS dialinfo"))?;
let mut requestb = di_wss_builder.init_request(
request
.len()
.try_into()
.map_err(map_error_protocol!("request too long"))?,
.map_err(RPCError::map_protocol("request too long"))?,
);
requestb.push_str(request.as_str());
}
veilid-core/src/rpc_processor/coders/dial_info_detail.rs
+2 -7
View File
@@ -19,15 +19,10 @@ pub fn decode_dial_info_detail(
&reader
.reborrow()
.get_dial_info()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
)?;
let class = decode_dial_info_class(
reader
.reborrow()
.get_class()
.map_err(map_error_capnp_notinschema!())?,
);
let class = decode_dial_info_class(reader.reborrow().get_class().map_err(RPCError::protocol)?);
Ok(DialInfoDetail { dial_info, class })
}
veilid-core/src/rpc_processor/coders/node_dial_info.rs
+6 -10
View File
@@ -15,16 +15,12 @@ pub fn encode_node_dial_info(
pub fn decode_node_dial_info(
reader: &veilid_capnp::node_dial_info::Reader,
) -> Result<NodeDialInfo, RPCError> {
let node_id = decode_public_key(
&reader
.get_node_id()
.map_err(map_error_protocol!("invalid public key in node_dial_info"))?,
);
let dial_info = decode_dial_info(
&reader
.get_dial_info()
.map_err(map_error_protocol!("invalid dial_info in node_dial_info"))?,
)?;
let node_id = decode_public_key(&reader.get_node_id().map_err(RPCError::map_protocol(
"invalid public key in node_dial_info",
))?);
let dial_info = decode_dial_info(&reader.get_dial_info().map_err(RPCError::map_protocol(
"invalid dial_info in node_dial_info",
))?)?;
Ok(NodeDialInfo {
node_id: NodeId::new(node_id),
veilid-core/src/rpc_processor/coders/node_info.rs
+7 -7
View File
@@ -18,8 +18,8 @@ pub fn encode_node_info(
.dial_info_detail_list
.len()
.try_into()
.map_err(map_error_protocol!(
"too many dial info details in node info"
.map_err(RPCError::map_protocol(
"too many dial info details in node info",
))?,
);
@@ -44,14 +44,14 @@ pub fn decode_node_info(
reader
.reborrow()
.get_network_class()
.map_err(map_error_capnp_notinschema!())?,
.map_err(RPCError::protocol)?,
);
let outbound_protocols = decode_protocol_set(
&reader
.reborrow()
.get_outbound_protocols()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
)?;
let min_version = reader.reborrow().get_min_version();
@@ -60,12 +60,12 @@ pub fn decode_node_info(
let didl_reader = reader
.reborrow()
.get_dial_info_detail_list()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let mut dial_info_detail_list = Vec::<DialInfoDetail>::with_capacity(
didl_reader
.len()
.try_into()
.map_err(map_error_protocol!("too many dial info details"))?,
.map_err(RPCError::map_protocol("too many dial info details"))?,
);
for did in didl_reader.iter() {
dial_info_detail_list.push(decode_dial_info_detail(&did)?)
@@ -77,7 +77,7 @@ pub fn decode_node_info(
&reader
.reborrow()
.get_relay_peer_info()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
false,
)?))
} else {
veilid-core/src/rpc_processor/coders/operations/answer.rs
+11 -11
View File
@@ -64,55 +64,55 @@ impl RPCAnswerDetail {
pub fn decode(
reader: &veilid_capnp::answer::detail::Reader,
) -> Result<RPCAnswerDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::answer::detail::StatusA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStatusA::decode(&op_reader)?;
RPCAnswerDetail::StatusA(out)
}
veilid_capnp::answer::detail::FindNodeA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindNodeA::decode(&op_reader)?;
RPCAnswerDetail::FindNodeA(out)
}
veilid_capnp::answer::detail::GetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationGetValueA::decode(&op_reader)?;
RPCAnswerDetail::GetValueA(out)
}
veilid_capnp::answer::detail::SetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSetValueA::decode(&op_reader)?;
RPCAnswerDetail::SetValueA(out)
}
veilid_capnp::answer::detail::WatchValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationWatchValueA::decode(&op_reader)?;
RPCAnswerDetail::WatchValueA(out)
}
veilid_capnp::answer::detail::SupplyBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSupplyBlockA::decode(&op_reader)?;
RPCAnswerDetail::SupplyBlockA(out)
}
veilid_capnp::answer::detail::FindBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindBlockA::decode(&op_reader)?;
RPCAnswerDetail::FindBlockA(out)
}
veilid_capnp::answer::detail::StartTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStartTunnelA::decode(&op_reader)?;
RPCAnswerDetail::StartTunnelA(out)
}
veilid_capnp::answer::detail::CompleteTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCompleteTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CompleteTunnelA(out)
}
veilid_capnp::answer::detail::CancelTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CancelTunnelA(out)
}
veilid-core/src/rpc_processor/coders/operations/operation.rs
+4 -6
View File
@@ -21,22 +21,20 @@ impl RPCOperationKind {
kind_reader: &veilid_capnp::operation::kind::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let which_reader = kind_reader
.which()
.map_err(map_error_capnp_notinschema!())?;
let which_reader = kind_reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::operation::kind::Which::Question(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCQuestion::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Question(out)
}
veilid_capnp::operation::kind::Which::Statement(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCStatement::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Statement(out)
}
veilid_capnp::operation::kind::Which::Answer(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCAnswer::decode(&q_reader)?;
RPCOperationKind::Answer(out)
}
veilid-core/src/rpc_processor/coders/operations/operation_cancel_tunnel.rs
+2 -2
View File
@@ -34,12 +34,12 @@ impl RPCOperationCancelTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_cancel_tunnel_a::Reader,
) -> Result<RPCOperationCancelTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_cancel_tunnel_a::Which::Tunnel(r) => {
Ok(RPCOperationCancelTunnelA::Tunnel(r))
}
veilid_capnp::operation_cancel_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationCancelTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_complete_tunnel.rs
+5 -8
View File
@@ -14,15 +14,12 @@ impl RPCOperationCompleteTunnelQ {
reader: &veilid_capnp::operation_complete_tunnel_q::Reader,
) -> Result<RPCOperationCompleteTunnelQ, RPCError> {
let id = reader.get_id();
let local_mode = match reader
.get_local_mode()
.map_err(map_error_capnp_notinschema!())?
{
let local_mode = match reader.get_local_mode().map_err(RPCError::protocol)? {
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
};
let depth = reader.get_depth();
let te_reader = reader.get_endpoint().map_err(map_error_capnp_error!())?;
let te_reader = reader.get_endpoint().map_err(RPCError::protocol)?;
let endpoint = decode_tunnel_endpoint(&te_reader)?;
Ok(RPCOperationCompleteTunnelQ {
@@ -59,14 +56,14 @@ impl RPCOperationCompleteTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_complete_tunnel_a::Reader,
) -> Result<RPCOperationCompleteTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_complete_tunnel_a::Which::Tunnel(r) => {
let ft_reader = r.map_err(map_error_capnp_error!())?;
let ft_reader = r.map_err(RPCError::protocol)?;
let full_tunnel = decode_full_tunnel(&ft_reader)?;
Ok(RPCOperationCompleteTunnelA::Tunnel(full_tunnel))
}
veilid_capnp::operation_complete_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationCompleteTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs
+8 -11
View File
@@ -10,7 +10,7 @@ impl RPCOperationFindBlockQ {
pub fn decode(
reader: &veilid_capnp::operation_find_block_q::Reader,
) -> Result<RPCOperationFindBlockQ, RPCError> {
let bi_reader = reader.get_block_id().map_err(map_error_capnp_error!())?;
let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
let block_id = decode_block_id(&bi_reader);
Ok(RPCOperationFindBlockQ { block_id })
@@ -37,29 +37,26 @@ impl RPCOperationFindBlockA {
pub fn decode(
reader: &veilid_capnp::operation_find_block_a::Reader,
) -> Result<RPCOperationFindBlockA, RPCError> {
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
let suppliers_reader = reader.get_suppliers().map_err(map_error_capnp_error!())?;
let suppliers_reader = reader.get_suppliers().map_err(RPCError::protocol)?;
let mut suppliers = Vec::<PeerInfo>::with_capacity(
suppliers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many suppliers"))?,
.map_err(RPCError::map_internal("too many suppliers"))?,
);
for s in suppliers_reader.iter() {
let peer_info = decode_peer_info(&s, true)?;
suppliers.push(peer_info);
}
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -83,7 +80,7 @@ impl RPCOperationFindBlockA {
self.suppliers
.len()
.try_into()
.map_err(map_error_internal!("invalid suppliers list length"))?,
.map_err(RPCError::map_internal("invalid suppliers list length"))?,
);
for (i, peer) in self.suppliers.iter().enumerate() {
let mut pi_builder = suppliers_builder.reborrow().get(i as u32);
@@ -94,7 +91,7 @@ impl RPCOperationFindBlockA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs
+4 -4
View File
@@ -10,7 +10,7 @@ impl RPCOperationFindNodeQ {
pub fn decode(
reader: &veilid_capnp::operation_find_node_q::Reader,
) -> Result<RPCOperationFindNodeQ, RPCError> {
let ni_reader = reader.get_node_id().map_err(map_error_capnp_error!())?;
let ni_reader = reader.get_node_id().map_err(RPCError::protocol)?;
let node_id = decode_public_key(&ni_reader);
Ok(RPCOperationFindNodeQ { node_id })
}
@@ -33,12 +33,12 @@ impl RPCOperationFindNodeA {
pub fn decode(
reader: &veilid_capnp::operation_find_node_a::Reader,
) -> Result<RPCOperationFindNodeA, RPCError> {
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -55,7 +55,7 @@ impl RPCOperationFindNodeA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid closest nodes list length"))?,
.map_err(RPCError::map_internal("invalid closest nodes list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_get_value.rs
+6 -6
View File
@@ -10,7 +10,7 @@ impl RPCOperationGetValueQ {
pub fn decode(
reader: &veilid_capnp::operation_get_value_q::Reader,
) -> Result<RPCOperationGetValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
Ok(RPCOperationGetValueQ { key })
}
@@ -34,18 +34,18 @@ impl RPCOperationGetValueA {
pub fn decode(
reader: &veilid_capnp::operation_get_value_a::Reader,
) -> Result<RPCOperationGetValueA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_get_value_a::Which::Data(r) => {
let data = decode_value_data(&r.map_err(map_error_capnp_error!())?)?;
let data = decode_value_data(&r.map_err(RPCError::protocol)?)?;
Ok(RPCOperationGetValueA::Data(data))
}
veilid_capnp::operation_get_value_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -70,7 +70,7 @@ impl RPCOperationGetValueA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_node_info_update.rs
+1 -3
View File
@@ -11,9 +11,7 @@ impl RPCOperationNodeInfoUpdate {
reader: &veilid_capnp::operation_node_info_update::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCOperationNodeInfoUpdate, RPCError> {
let sni_reader = reader
.get_signed_node_info()
.map_err(map_error_capnp_error!())?;
let sni_reader = reader.get_signed_node_info().map_err(RPCError::protocol)?;
let signed_node_info = decode_signed_node_info(&sni_reader, sender_node_id, true)?;
Ok(RPCOperationNodeInfoUpdate { signed_node_info })
veilid-core/src/rpc_processor/coders/operations/operation_return_receipt.rs
+1 -1
View File
@@ -10,7 +10,7 @@ impl RPCOperationReturnReceipt {
pub fn decode(
reader: &veilid_capnp::operation_return_receipt::Reader,
) -> Result<RPCOperationReturnReceipt, RPCError> {
let rcpt_reader = reader.get_receipt().map_err(map_error_capnp_error!())?;
let rcpt_reader = reader.get_receipt().map_err(RPCError::protocol)?;
let receipt = rcpt_reader.to_vec();
Ok(RPCOperationReturnReceipt { receipt })
veilid-core/src/rpc_processor/coders/operations/operation_route.rs
+7 -12
View File
@@ -20,24 +20,21 @@ impl RoutedOperation {
pub fn decode(
reader: &veilid_capnp::routed_operation::Reader,
) -> Result<RoutedOperation, RPCError> {
let sigs_reader = reader.get_signatures().map_err(map_error_capnp_error!())?;
let sigs_reader = reader.get_signatures().map_err(RPCError::protocol)?;
let mut signatures = Vec::<DHTSignature>::with_capacity(
sigs_reader
.len()
.try_into()
.map_err(map_error_internal!("too many signatures"))?,
.map_err(RPCError::map_internal("too many signatures"))?,
);
for s in sigs_reader.iter() {
let sig = decode_signature(&s);
signatures.push(sig);
}
let n_reader = reader.get_nonce().map_err(map_error_capnp_error!())?;
let n_reader = reader.get_nonce().map_err(RPCError::protocol)?;
let nonce = decode_nonce(&n_reader);
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
Ok(RoutedOperation {
signatures,
@@ -54,7 +51,7 @@ impl RoutedOperation {
self.signatures
.len()
.try_into()
.map_err(map_error_internal!("invalid signatures list length"))?,
.map_err(RPCError::map_internal("invalid signatures list length"))?,
);
for (i, sig) in self.signatures.iter().enumerate() {
let mut sig_builder = sigs_builder.reborrow().get(i as u32);
@@ -78,12 +75,10 @@ impl RPCOperationRoute {
pub fn decode(
reader: &veilid_capnp::operation_route::Reader,
) -> Result<RPCOperationRoute, RPCError> {
let sr_reader = reader
.get_safety_route()
.map_err(map_error_capnp_error!())?;
let sr_reader = reader.get_safety_route().map_err(RPCError::protocol)?;
let safety_route = decode_safety_route(&sr_reader)?;
let o_reader = reader.get_operation().map_err(map_error_capnp_error!())?;
let o_reader = reader.get_operation().map_err(RPCError::protocol)?;
let operation = RoutedOperation::decode(&o_reader)?;
Ok(RPCOperationRoute {
veilid-core/src/rpc_processor/coders/operations/operation_set_value.rs
+7 -7
View File
@@ -11,9 +11,9 @@ impl RPCOperationSetValueQ {
pub fn decode(
reader: &veilid_capnp::operation_set_value_q::Reader,
) -> Result<RPCOperationSetValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
let v_reader = reader.get_value().map_err(map_error_capnp_error!())?;
let v_reader = reader.get_value().map_err(RPCError::protocol)?;
let value = decode_value_data(&v_reader)?;
Ok(RPCOperationSetValueQ { key, value })
}
@@ -39,18 +39,18 @@ impl RPCOperationSetValueA {
pub fn decode(
reader: &veilid_capnp::operation_set_value_a::Reader,
) -> Result<RPCOperationSetValueA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_set_value_a::Which::Data(r) => {
let data = decode_value_data(&r.map_err(map_error_capnp_error!())?)?;
let data = decode_value_data(&r.map_err(RPCError::protocol)?)?;
Ok(RPCOperationSetValueA::Data(data))
}
veilid_capnp::operation_set_value_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -75,7 +75,7 @@ impl RPCOperationSetValueA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_start_tunnel.rs
+4 -7
View File
@@ -13,10 +13,7 @@ impl RPCOperationStartTunnelQ {
reader: &veilid_capnp::operation_start_tunnel_q::Reader,
) -> Result<RPCOperationStartTunnelQ, RPCError> {
let id = reader.get_id();
let local_mode = match reader
.get_local_mode()
.map_err(map_error_capnp_notinschema!())?
{
let local_mode = match reader.get_local_mode().map_err(RPCError::protocol)? {
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
};
@@ -53,14 +50,14 @@ impl RPCOperationStartTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_start_tunnel_a::Reader,
) -> Result<RPCOperationStartTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_start_tunnel_a::Which::Partial(r) => {
let pt_reader = r.map_err(map_error_capnp_error!())?;
let pt_reader = r.map_err(RPCError::protocol)?;
let partial_tunnel = decode_partial_tunnel(&pt_reader)?;
Ok(RPCOperationStartTunnelA::Partial(partial_tunnel))
}
veilid_capnp::operation_start_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationStartTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_status.rs
+3 -3
View File
@@ -10,7 +10,7 @@ impl RPCOperationStatusQ {
pub fn decode(
reader: &veilid_capnp::operation_status_q::Reader,
) -> Result<RPCOperationStatusQ, RPCError> {
let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?;
let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
let node_status = decode_node_status(&ns_reader)?;
Ok(RPCOperationStatusQ { node_status })
}
@@ -34,10 +34,10 @@ impl RPCOperationStatusA {
pub fn decode(
reader: &veilid_capnp::operation_status_a::Reader,
) -> Result<RPCOperationStatusA, RPCError> {
let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?;
let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
let node_status = decode_node_status(&ns_reader)?;
let si_reader = reader.get_sender_info().map_err(map_error_capnp_error!())?;
let si_reader = reader.get_sender_info().map_err(RPCError::protocol)?;
let sender_info = decode_sender_info(&si_reader)?;
Ok(RPCOperationStatusA {
veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs
+5 -5
View File
@@ -10,7 +10,7 @@ impl RPCOperationSupplyBlockQ {
pub fn decode(
reader: &veilid_capnp::operation_supply_block_q::Reader,
) -> Result<RPCOperationSupplyBlockQ, RPCError> {
let bi_reader = reader.get_block_id().map_err(map_error_capnp_error!())?;
let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
let block_id = decode_block_id(&bi_reader);
Ok(RPCOperationSupplyBlockQ { block_id })
@@ -36,17 +36,17 @@ impl RPCOperationSupplyBlockA {
pub fn decode(
reader: &veilid_capnp::operation_supply_block_a::Reader,
) -> Result<RPCOperationSupplyBlockA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_supply_block_a::Which::Expiration(r) => {
Ok(RPCOperationSupplyBlockA::Expiration(r))
}
veilid_capnp::operation_supply_block_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -70,7 +70,7 @@ impl RPCOperationSupplyBlockA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_validate_dial_info.rs
+2 -2
View File
@@ -12,9 +12,9 @@ impl RPCOperationValidateDialInfo {
pub fn decode(
reader: &veilid_capnp::operation_validate_dial_info::Reader,
) -> Result<RPCOperationValidateDialInfo, RPCError> {
let di_reader = reader.get_dial_info().map_err(map_error_capnp_error!())?;
let di_reader = reader.get_dial_info().map_err(RPCError::protocol)?;
let dial_info = decode_dial_info(&di_reader)?;
let rcpt_reader = reader.get_receipt().map_err(map_error_capnp_error!())?;
let rcpt_reader = reader.get_receipt().map_err(RPCError::protocol)?;
let receipt = rcpt_reader.to_vec();
let redirect = reader.get_redirect();
veilid-core/src/rpc_processor/coders/operations/operation_value_changed.rs
+2 -2
View File
@@ -11,9 +11,9 @@ impl RPCOperationValueChanged {
pub fn decode(
reader: &veilid_capnp::operation_value_changed::Reader,
) -> Result<RPCOperationValueChanged, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
let v_reader = reader.get_value().map_err(map_error_capnp_error!())?;
let v_reader = reader.get_value().map_err(RPCError::protocol)?;
let value = decode_value_data(&v_reader)?;
Ok(RPCOperationValueChanged { key, value })
}
veilid-core/src/rpc_processor/coders/operations/operation_watch_value.rs
+4 -4
View File
@@ -10,7 +10,7 @@ impl RPCOperationWatchValueQ {
pub fn decode(
reader: &veilid_capnp::operation_watch_value_q::Reader,
) -> Result<RPCOperationWatchValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
Ok(RPCOperationWatchValueQ { key })
}
@@ -35,12 +35,12 @@ impl RPCOperationWatchValueA {
reader: &veilid_capnp::operation_watch_value_a::Reader,
) -> Result<RPCOperationWatchValueA, RPCError> {
let expiration = reader.get_expiration();
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -59,7 +59,7 @@ impl RPCOperationWatchValueA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/question.rs
+11 -11
View File
@@ -78,55 +78,55 @@ impl RPCQuestionDetail {
pub fn decode(
reader: &veilid_capnp::question::detail::Reader,
) -> Result<RPCQuestionDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::question::detail::StatusQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStatusQ::decode(&op_reader)?;
RPCQuestionDetail::StatusQ(out)
}
veilid_capnp::question::detail::FindNodeQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindNodeQ::decode(&op_reader)?;
RPCQuestionDetail::FindNodeQ(out)
}
veilid_capnp::question::detail::GetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationGetValueQ::decode(&op_reader)?;
RPCQuestionDetail::GetValueQ(out)
}
veilid_capnp::question::detail::SetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSetValueQ::decode(&op_reader)?;
RPCQuestionDetail::SetValueQ(out)
}
veilid_capnp::question::detail::WatchValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationWatchValueQ::decode(&op_reader)?;
RPCQuestionDetail::WatchValueQ(out)
}
veilid_capnp::question::detail::SupplyBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSupplyBlockQ::decode(&op_reader)?;
RPCQuestionDetail::SupplyBlockQ(out)
}
veilid_capnp::question::detail::FindBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindBlockQ::decode(&op_reader)?;
RPCQuestionDetail::FindBlockQ(out)
}
veilid_capnp::question::detail::StartTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStartTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::StartTunnelQ(out)
}
veilid_capnp::question::detail::CompleteTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CompleteTunnelQ(out)
}
veilid_capnp::question::detail::CancelTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CancelTunnelQ(out)
}
veilid-core/src/rpc_processor/coders/operations/respond_to.rs
+6 -13
View File
@@ -32,25 +32,18 @@ impl RespondTo {
reader: &veilid_capnp::question::respond_to::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let respond_to = match reader.which().map_err(map_error_capnp_notinschema!())? {
veilid_capnp::question::respond_to::Sender(_) => RespondTo::Sender(None),
veilid_capnp::question::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => {
let respond_to = match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::question::respond_to::Sender(()) => RespondTo::Sender(None),
veilid_capnp::question::respond_to::SenderWithInfo(sender_ni_reader) => {
let sender_ni_reader = sender_ni_reader.map_err(RPCError::protocol)?;
let sni = decode_signed_node_info(&sender_ni_reader, sender_node_id, true)?;
RespondTo::Sender(Some(sni))
}
veilid_capnp::question::respond_to::SenderWithInfo(Err(e)) => {
return Err(rpc_error_protocol(format!(
"invalid signed node info: {}",
e
)))
}
veilid_capnp::question::respond_to::PrivateRoute(Ok(pr_reader)) => {
veilid_capnp::question::respond_to::PrivateRoute(pr_reader) => {
let pr_reader = pr_reader.map_err(RPCError::protocol)?;
let pr = decode_private_route(&pr_reader)?;
RespondTo::PrivateRoute(pr)
}
veilid_capnp::question::respond_to::PrivateRoute(Err(e)) => {
return Err(rpc_error_protocol(format!("invalid private route: {}", e)));
}
};
Ok(respond_to)
}
veilid-core/src/rpc_processor/coders/operations/statement.rs
+7 -7
View File
@@ -59,35 +59,35 @@ impl RPCStatementDetail {
reader: &veilid_capnp::statement::detail::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCStatementDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::statement::detail::ValidateDialInfo(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationValidateDialInfo::decode(&op_reader)?;
RPCStatementDetail::ValidateDialInfo(out)
}
veilid_capnp::statement::detail::Route(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationRoute::decode(&op_reader)?;
RPCStatementDetail::Route(out)
}
veilid_capnp::statement::detail::NodeInfoUpdate(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationNodeInfoUpdate::decode(&op_reader, sender_node_id)?;
RPCStatementDetail::NodeInfoUpdate(out)
}
veilid_capnp::statement::detail::ValueChanged(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationValueChanged::decode(&op_reader)?;
RPCStatementDetail::ValueChanged(out)
}
veilid_capnp::statement::detail::Signal(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSignal::decode(&op_reader)?;
RPCStatementDetail::Signal(out)
}
veilid_capnp::statement::detail::ReturnReceipt(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCStatementDetail::ReturnReceipt(out)
}
veilid-core/src/rpc_processor/coders/peer_info.rs
+2 -2
View File
@@ -21,11 +21,11 @@ pub fn decode_peer_info(
let nid_reader = reader
.reborrow()
.get_node_id()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let sni_reader = reader
.reborrow()
.get_signed_node_info()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
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)?;
veilid-core/src/rpc_processor/coders/private_safety_route.rs
+25 -24
View File
@@ -83,13 +83,17 @@ pub fn encode_route_hop_data(
//
let mut nonce_builder = builder.reborrow().init_nonce();
encode_nonce(&route_hop_data.nonce, &mut nonce_builder);
let blob_builder = builder.reborrow().init_blob(
route_hop_data
.blob
.len()
.try_into()
.map_err(map_error_protocol!("invalid blob length in route hop data"))?,
);
let blob_builder = builder
.reborrow()
.init_blob(
route_hop_data
.blob
.len()
.try_into()
.map_err(RPCError::map_protocol(
"invalid blob length in route hop data",
))?,
);
blob_builder.copy_from_slice(route_hop_data.blob.as_slice());
Ok(())
}
@@ -157,13 +161,13 @@ pub fn decode_route_hop_data(
&reader
.reborrow()
.get_nonce()
.map_err(map_error_protocol!("invalid nonce in route hop data"))?,
.map_err(RPCError::map_protocol("invalid nonce in route hop data"))?,
);
let blob = reader
.reborrow()
.get_blob()
.map_err(map_error_protocol!("invalid blob in route hop data"))?
.map_err(RPCError::map_protocol("invalid blob in route hop data"))?
.to_vec();
Ok(RouteHopData { nonce, blob })
@@ -174,13 +178,13 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
&reader
.reborrow()
.get_dial_info()
.map_err(map_error_protocol!("invalid dial info in route hop"))?,
.map_err(RPCError::map_protocol("invalid dial info in route hop"))?,
)?;
let next_hop = if reader.has_next_hop() {
let rhd_reader = reader
.get_next_hop()
.map_err(map_error_protocol!("invalid next hop in route hop"))?;
.map_err(RPCError::map_protocol("invalid next hop in route hop"))?;
Some(decode_route_hop_data(&rhd_reader)?)
} else {
None
@@ -195,16 +199,14 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
pub fn decode_private_route(
reader: &veilid_capnp::private_route::Reader,
) -> Result<PrivateRoute, RPCError> {
let public_key = decode_public_key(
&reader
.get_public_key()
.map_err(map_error_protocol!("invalid public key in private route"))?,
);
let public_key = decode_public_key(&reader.get_public_key().map_err(
RPCError::map_protocol("invalid public key in private route"),
)?);
let hop_count = reader.get_hop_count();
let hops = if reader.has_first_hop() {
let rh_reader = reader
.get_first_hop()
.map_err(map_error_protocol!("invalid first hop in private route"))?;
.map_err(RPCError::map_protocol("invalid first hop in private route"))?;
Some(decode_route_hop(&rh_reader)?)
} else {
None
@@ -223,19 +225,18 @@ pub fn decode_safety_route(
let public_key = decode_public_key(
&reader
.get_public_key()
.map_err(map_error_protocol!("invalid public key in safety route"))?,
.map_err(RPCError::map_protocol("invalid public key in safety route"))?,
);
let hop_count = reader.get_hop_count();
let hops = match reader.get_hops().which() {
Ok(veilid_capnp::safety_route::hops::Which::Data(Ok(rhd_reader))) => {
let hops = match reader.get_hops().which().map_err(RPCError::protocol)? {
veilid_capnp::safety_route::hops::Which::Data(rhd_reader) => {
let rhd_reader = rhd_reader.map_err(RPCError::protocol)?;
SafetyRouteHops::Data(decode_route_hop_data(&rhd_reader)?)
}
Ok(veilid_capnp::safety_route::hops::Which::Private(Ok(pr_reader))) => {
veilid_capnp::safety_route::hops::Which::Private(pr_reader) => {
let pr_reader = pr_reader.map_err(RPCError::protocol)?;
SafetyRouteHops::Private(decode_private_route(&pr_reader)?)
}
_ => {
return Err(rpc_error_protocol("invalid hops in safety route"));
}
};
Ok(SafetyRoute {
veilid-core/src/rpc_processor/coders/public_key.rs
+5 -5
View File
@@ -23,27 +23,27 @@ pub fn encode_public_key(
builder: &mut veilid_capnp::curve25519_public_key::Builder,
) -> Result<(), RPCError> {
if !key.valid {
return Err(rpc_error_protocol("invalid key"));
return Err(RPCError::protocol("invalid key"));
}
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
Ok(())
}
veilid-core/src/rpc_processor/coders/sender_info.rs
+4 -2
View File
@@ -16,14 +16,16 @@ pub fn decode_sender_info(
reader: &veilid_capnp::sender_info::Reader,
) -> Result<SenderInfo, RPCError> {
if !reader.has_socket_address() {
return Err(rpc_error_internal("invalid socket address type"));
return Err(RPCError::internal("invalid socket address type"));
}
let socket_address = if reader.has_socket_address() {
Some(decode_socket_address(
&reader
.reborrow()
.get_socket_address()
.map_err(map_error_internal!("invalid socket address in sender_info"))?,
.map_err(RPCError::map_internal(
"invalid socket address in sender_info",
))?,
)?)
} else {
None
veilid-core/src/rpc_processor/coders/signal_info.rs
+15 -21
View File
@@ -10,8 +10,8 @@ pub fn encode_signal_info(
let mut hp_builder = builder.reborrow().init_hole_punch();
let r_builder = hp_builder
.reborrow()
.init_receipt(receipt.len().try_into().map_err(map_error_protocol!(
"invalid receipt length in encode_signal_info"
.init_receipt(receipt.len().try_into().map_err(RPCError::map_protocol(
"invalid receipt length in encode_signal_info",
))?);
r_builder.copy_from_slice(receipt);
let mut pi_builder = hp_builder.init_peer_info();
@@ -21,8 +21,8 @@ pub fn encode_signal_info(
let mut rc_builder = builder.reborrow().init_reverse_connect();
let r_builder = rc_builder
.reborrow()
.init_receipt(receipt.len().try_into().map_err(map_error_protocol!(
"invalid receipt length in encode_signal_info"
.init_receipt(receipt.len().try_into().map_err(RPCError::map_protocol(
"invalid receipt length in encode_signal_info",
))?);
r_builder.copy_from_slice(receipt);
let mut pi_builder = rc_builder.init_peer_info();
@@ -39,22 +39,19 @@ pub fn decode_signal_info(
Ok(
match reader
.which()
.map_err(map_error_internal!("invalid signal operation"))?
.map_err(RPCError::map_internal("invalid signal operation"))?
{
veilid_capnp::operation_signal::HolePunch(r) => {
// Extract hole punch reader
let r = match r {
Ok(r) => r,
Err(_) => return Err(rpc_error_internal("invalid hole punch")),
};
let r = r.map_err(RPCError::protocol)?;
let receipt = r
.get_receipt()
.map_err(map_error_protocol!(
"invalid receipt in hole punch signal info"
.map_err(RPCError::map_protocol(
"invalid receipt in hole punch signal info",
))?
.to_vec();
let pi_reader = r.get_peer_info().map_err(map_error_protocol!(
"invalid peer info in hole punch signal info"
let pi_reader = r.get_peer_info().map_err(RPCError::map_protocol(
"invalid peer info in hole punch signal info",
))?;
let peer_info = decode_peer_info(&pi_reader, true)?;
@@ -62,18 +59,15 @@ pub fn decode_signal_info(
}
veilid_capnp::operation_signal::ReverseConnect(r) => {
// Extract reverse connect reader
let r = match r {
Ok(r) => r,
Err(_) => return Err(rpc_error_internal("invalid reverse connect")),
};
let r = r.map_err(RPCError::protocol)?;
let receipt = r
.get_receipt()
.map_err(map_error_protocol!(
"invalid receipt in hole punch signal info"
.map_err(RPCError::map_protocol(
"invalid receipt in hole punch signal info",
))?
.to_vec();
let pi_reader = r.get_peer_info().map_err(map_error_protocol!(
"invalid peer info in reverse connect signal info"
let pi_reader = r.get_peer_info().map_err(RPCError::map_protocol(
"invalid peer info in reverse connect signal info",
))?;
let peer_info = decode_peer_info(&pi_reader, true)?;
veilid-core/src/rpc_processor/coders/signed_node_info.rs
+3 -3
View File
@@ -25,17 +25,17 @@ pub fn decode_signed_node_info(
let ni_reader = reader
.reborrow()
.get_node_info()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
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!())?;
.map_err(RPCError::protocol)?;
let signature = decode_signature(&sig_reader);
let timestamp = reader.reborrow().get_timestamp();
SignedNodeInfo::new(node_info, NodeId::new(*node_id), signature, timestamp)
.map_err(map_error_string!())
.map_err(RPCError::protocol)
}
veilid-core/src/rpc_processor/coders/socket_address.rs
+1 -1
View File
@@ -17,7 +17,7 @@ pub fn decode_socket_address(
let ar = reader
.reborrow()
.get_address()
.map_err(map_error_internal!("missing socketAddress"))?;
.map_err(RPCError::map_internal("missing socketAddress"))?;
let address = decode_address(&ar)?;
let port = reader.get_port();
veilid-core/src/rpc_processor/coders/tunnel.rs
+5 -5
View File
@@ -46,10 +46,10 @@ pub fn encode_tunnel_endpoint(
pub fn decode_tunnel_endpoint(
reader: &veilid_capnp::tunnel_endpoint::Reader,
) -> Result<TunnelEndpoint, RPCError> {
let mode = decode_tunnel_mode(reader.get_mode().map_err(map_error_capnp_notinschema!())?);
let mode = decode_tunnel_mode(reader.get_mode().map_err(RPCError::protocol)?);
let description = reader
.get_description()
.map_err(map_error_capnp_error!())?
.map_err(RPCError::protocol)?
.to_owned();
Ok(TunnelEndpoint { mode, description })
@@ -73,9 +73,9 @@ pub fn decode_full_tunnel(
) -> Result<FullTunnel, RPCError> {
let id = reader.get_id();
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(RPCError::protocol)?;
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(RPCError::protocol)?;
let remote = decode_tunnel_endpoint(&r_reader)?;
Ok(FullTunnel {
@@ -102,7 +102,7 @@ pub fn decode_partial_tunnel(
) -> Result<PartialTunnel, RPCError> {
let id = reader.get_id();
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(RPCError::protocol)?;
let local = decode_tunnel_endpoint(&l_reader)?;
Ok(PartialTunnel { id, timeout, local })
veilid-core/src/rpc_processor/coders/value_data.rs
+1 -4
View File
@@ -11,10 +11,7 @@ pub fn encode_value_data(
}
pub fn decode_value_data(reader: &veilid_capnp::value_data::Reader) -> Result<ValueData, RPCError> {
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
let seq = reader.get_seq();
Ok(ValueData { data, seq })
}
veilid-core/src/rpc_processor/coders/value_key.rs
+2 -2
View File
@@ -14,12 +14,12 @@ pub fn encode_value_key(
}
pub fn decode_value_key(reader: &veilid_capnp::value_key::Reader) -> Result<ValueKey, RPCError> {
let pk_reader = reader.get_public_key().map_err(map_error_capnp_error!())?;
let pk_reader = reader.get_public_key().map_err(RPCError::protocol)?;
let key = decode_public_key(&pk_reader);
let subkey = if !reader.has_subkey() {
None
} else {
let subkey = reader.get_subkey().map_err(map_error_capnp_error!())?;
let subkey = reader.get_subkey().map_err(RPCError::protocol)?;
Some(subkey.to_owned())
};
Ok(ValueKey { key, subkey })