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

continue to refactor

Browse Source
This commit is contained in:
John Smith
2021-12-21 22:20:55 -05:00
parent c0a42ac90c
commit 5826551763
22 changed files with 381 additions and 551 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
veilid-core/src/rpc_processor/coders/address.rs
View File

@@ -35,14 +35,6 @@ pub fn encode_address(
.expect("slice with incorrect length"),
));
}
Address::Hostname(h) => {
let mut tb = builder.reborrow().init_hostname(
h.len()
.try_into()
.map_err(map_error_internal!("hostname too long"))?,
);
tb.push_str(h.as_str());
}
};
Ok(())
}
@@ -63,7 +55,6 @@ 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],
])))
}
Ok(veilid_capnp::address::Which::Hostname(Ok(tr))) => Ok(Address::Hostname(tr.to_owned())),
_ => Err(rpc_error_internal("invalid address type")),
_ => Err(rpc_error_protocol("invalid address type")),
}
}

108
veilid-core/src/rpc_processor/coders/dial_info.rs
View File

@@ -6,40 +6,40 @@ 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))) => {
let address_reader = udp
.get_address()
.map_err(map_error_internal!("missing udp address"))?;
let address = decode_address(&address_reader)?;
let port = udp.get_port();
Ok(DialInfo::udp(address, port))
let socket_address_reader = udp
.get_socket_address()
.map_err(map_error_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))) => {
let address_reader = tcp
.get_address()
.map_err(map_error_internal!("missing tcp address"))?;
let address = decode_address(&address_reader)?;
let port = tcp.get_port();
Ok(DialInfo::tcp(address, port))
let socket_address_reader = tcp
.get_socket_address()
.map_err(map_error_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))) => {
let host = ws
.get_host()
.map_err(map_error_internal!("missing ws host"))?;
let port = ws.get_port();
let path = ws
.get_path()
.map_err(map_error_internal!("missing ws path"))?;
Ok(DialInfo::ws(host.to_owned(), port, path.to_owned()))
let socket_address_reader = ws
.get_socket_address()
.map_err(map_error_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"))?;
DialInfo::try_ws(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WS dial info"))
}
Ok(veilid_capnp::dial_info::Which::Wss(Ok(wss))) => {
let host = wss
.get_host()
.map_err(map_error_internal!("missing wss host"))?;
let port = wss.get_port();
let path = wss
.get_path()
.map_err(map_error_internal!("missing wss path"))?;
Ok(DialInfo::wss(host.to_owned(), port, path.to_owned()))
let socket_address_reader = wss
.get_socket_address()
.map_err(map_error_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"))?;
DialInfo::try_wss(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WSS dial info"))
}
_ => Err(rpc_error_internal("invalid dial info type")),
}
@@ -52,49 +52,45 @@ pub fn encode_dial_info(
match dial_info {
DialInfo::UDP(udp) => {
let mut di_udp_builder = builder.reborrow().init_udp();
encode_address(&udp.address, &mut di_udp_builder.reborrow().init_address())?;
di_udp_builder.set_port(udp.port);
encode_socket_address(
&udp.socket_address,
&mut di_udp_builder.reborrow().init_socket_address(),
)?;
}
DialInfo::TCP(tcp) => {
let mut di_tcp_builder = builder.reborrow().init_tcp();
encode_address(&tcp.address, &mut di_tcp_builder.reborrow().init_address())?;
di_tcp_builder.set_port(tcp.port);
encode_socket_address(
&tcp.socket_address,
&mut di_tcp_builder.reborrow().init_socket_address(),
)?;
}
DialInfo::WS(ws) => {
let mut di_ws_builder = builder.reborrow().init_ws();
let mut hostb = di_ws_builder.reborrow().init_host(
ws.host
encode_socket_address(
&ws.socket_address,
&mut di_ws_builder.reborrow().init_socket_address(),
)?;
let mut requestb = di_ws_builder.init_request(
ws.request
.len()
.try_into()
.map_err(map_error_internal!("host too long"))?,
.map_err(map_error_protocol!("request too long"))?,
);
hostb.push_str(ws.host.as_str());
di_ws_builder.set_port(ws.port);
let mut pathb = di_ws_builder.init_path(
ws.path
.len()
.try_into()
.map_err(map_error_internal!("path too long"))?,
);
pathb.push_str(ws.path.as_str());
requestb.push_str(ws.request.as_str());
}
DialInfo::WSS(wss) => {
let mut di_wss_builder = builder.reborrow().init_wss();
let mut hostb = di_wss_builder.reborrow().init_host(
wss.host
encode_socket_address(
&wss.socket_address,
&mut di_wss_builder.reborrow().init_socket_address(),
)?;
let mut requestb = di_wss_builder.init_request(
wss.request
.len()
.try_into()
.map_err(map_error_internal!("host too long"))?,
.map_err(map_error_protocol!("request too long"))?,
);
hostb.push_str(wss.host.as_str());
di_wss_builder.set_port(wss.port);
let mut pathb = di_wss_builder.init_path(
wss.path
.len()
.try_into()
.map_err(map_error_internal!("path too long"))?,
);
pathb.push_str(wss.path.as_str());
requestb.push_str(wss.request.as_str());
}
};
Ok(())

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

@@ -15,10 +15,10 @@ pub fn encode_node_dial_info_single(
pub fn decode_node_dial_info_single(
reader: &veilid_capnp::node_dial_info_single::Reader,
) -> Result<NodeDialInfoSingle, RPCError> {
let node_id = decode_public_key(&reader.get_node_id().map_err(map_error_internal!(
let node_id = decode_public_key(&reader.get_node_id().map_err(map_error_protocol!(
"invalid public key in node_dial_info_single"
))?);
let dial_info = decode_dial_info(&reader.get_dial_info().map_err(map_error_internal!(
let dial_info = decode_dial_info(&reader.get_dial_info().map_err(map_error_protocol!(
"invalid dial_info in node_dial_info_single"
))?)?;

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

@@ -15,7 +15,7 @@ pub fn encode_peer_info(
.dial_infos
.len()
.try_into()
.map_err(map_error_internal!("too many dial infos in peer info"))?,
.map_err(map_error_protocol!("too many dial infos in peer info"))?,
);
for idx in 0..peer_info.dial_infos.len() {
@@ -38,7 +38,7 @@ pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result<Peer
dil_reader
.len()
.try_into()
.map_err(map_error_internal!("too many dial infos"))?,
.map_err(map_error_protocol!("too many dial infos"))?,
);
for di in dil_reader.iter() {
dial_infos.push(decode_dial_info(&di)?)

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

@@ -51,7 +51,7 @@ pub fn encode_route_hop_data(
.blob
.len()
.try_into()
.map_err(map_error_internal!("invalid blob length in route hop data"))?,
.map_err(map_error_protocol!("invalid blob length in route hop data"))?,
);
blob_builder.copy_from_slice(route_hop_data.blob.as_slice());
Ok(())
@@ -120,13 +120,13 @@ pub fn decode_route_hop_data(
&reader
.reborrow()
.get_nonce()
.map_err(map_error_internal!("invalid nonce in route hop data"))?,
.map_err(map_error_protocol!("invalid nonce in route hop data"))?,
);
let blob = reader
.reborrow()
.get_blob()
.map_err(map_error_internal!("invalid blob in route hop data"))?
.map_err(map_error_protocol!("invalid blob in route hop data"))?
.to_vec();
Ok(RouteHopData { nonce, blob })
@@ -137,13 +137,13 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
&reader
.reborrow()
.get_dial_info()
.map_err(map_error_internal!("invalid dial info in route hop"))?,
.map_err(map_error_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_internal!("invalid next hop in route hop"))?;
.map_err(map_error_protocol!("invalid next hop in route hop"))?;
Some(decode_route_hop_data(&rhd_reader)?)
} else {
None
@@ -161,13 +161,13 @@ pub fn decode_private_route(
let public_key = decode_public_key(
&reader
.get_public_key()
.map_err(map_error_internal!("invalid public key in private route"))?,
.map_err(map_error_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_internal!("invalid first hop in private route"))?;
.map_err(map_error_protocol!("invalid first hop in private route"))?;
Some(decode_route_hop(&rh_reader)?)
} else {
None
@@ -186,7 +186,7 @@ pub fn decode_safety_route(
let public_key = decode_public_key(
&reader
.get_public_key()
.map_err(map_error_internal!("invalid public key in safety route"))?,
.map_err(map_error_protocol!("invalid public key in safety route"))?,
);
let hop_count = reader.get_hop_count();
let hops = match reader.get_hops().which() {
@@ -197,7 +197,7 @@ pub fn decode_safety_route(
SafetyRouteHops::Private(decode_private_route(&pr_reader)?)
}
_ => {
return Err(rpc_error_internal("invalid hops in safety route"));
return Err(rpc_error_protocol("invalid hops in safety route"));
}
};

10
veilid-core/src/rpc_processor/coders/public_key.rs
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_internal("invalid key"));
return Err(rpc_error_protocol("invalid key"));
}
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(map_error_internal!("slice with incorrect length"))?,
.map_err(map_error_protocol!("slice with incorrect length"))?,
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(map_error_internal!("slice with incorrect length"))?,
.map_err(map_error_protocol!("slice with incorrect length"))?,
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(map_error_internal!("slice with incorrect length"))?,
.map_err(map_error_protocol!("slice with incorrect length"))?,
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(map_error_internal!("slice with incorrect length"))?,
.map_err(map_error_protocol!("slice with incorrect length"))?,
));
Ok(())
}

73
veilid-core/src/rpc_processor/coders/socket_address.rs
View File

@@ -1,72 +1,25 @@
use crate::xx::*;
use crate::*;
use core::convert::TryInto;
use rpc_processor::*;
pub fn encode_socket_address(
address: &SocketAddr,
socket_address: &SocketAddress,
builder: &mut veilid_capnp::socket_address::Builder,
) -> Result<(), RPCError> {
match address {
SocketAddr::V4(v4) => {
let mut v4b = builder.reborrow().init_ipv4();
v4b.set_addr(u32::from_be_bytes(v4.ip().octets()));
builder.set_port(v4.port());
}
SocketAddr::V6(v6) => {
let mut v6b = builder.reborrow().init_ipv6();
v6b.set_addr0(u32::from_be_bytes(
v6.ip().octets()[0..4]
.try_into()
.expect("slice with incorrect length"),
));
v6b.set_addr1(u32::from_be_bytes(
v6.ip().octets()[4..8]
.try_into()
.expect("slice with incorrect length"),
));
v6b.set_addr2(u32::from_be_bytes(
v6.ip().octets()[8..12]
.try_into()
.expect("slice with incorrect length"),
));
v6b.set_addr3(u32::from_be_bytes(
v6.ip().octets()[12..16]
.try_into()
.expect("slice with incorrect length"),
));
builder.set_port(v6.port());
}
};
let mut ab = builder.reborrow().init_address();
encode_address(&socket_address.address(), &mut ab)?;
builder.set_port(socket_address.port());
Ok(())
}
pub fn decode_socket_address(
reader: &veilid_capnp::socket_address::Reader,
) -> Result<SocketAddr, RPCError> {
match reader.reborrow().which() {
Ok(veilid_capnp::socket_address::Which::Ipv4(Ok(v4))) => {
let v4b = v4.get_addr().to_be_bytes();
Ok(SocketAddr::V4(SocketAddrV4::new(
Ipv4Addr::new(v4b[0], v4b[1], v4b[2], v4b[3]),
reader.get_port(),
)))
}
Ok(veilid_capnp::socket_address::Which::Ipv6(Ok(v6))) => {
let v6b0 = v6.get_addr0().to_be_bytes();
let v6b1 = v6.get_addr1().to_be_bytes();
let v6b2 = v6.get_addr2().to_be_bytes();
let v6b3 = v6.get_addr3().to_be_bytes();
Ok(SocketAddr::V6(SocketAddrV6::new(
Ipv6Addr::from([
v6b0[0], v6b0[1], v6b0[2], v6b0[3], v6b1[0], v6b1[1], v6b1[2], v6b1[3],
v6b2[0], v6b2[1], v6b2[2], v6b2[3], v6b3[0], v6b3[1], v6b3[2], v6b3[3],
]),
reader.get_port(),
0,
0,
)))
}
_ => Err(rpc_error_internal("invalid socket address type")),
}
) -> Result<SocketAddress, RPCError> {
let ar = reader
.reborrow()
.get_address()
.map_err(map_error_internal!("missing socketAddress"))?;
let address = decode_address(&ar)?;
let port = reader.get_port();
Ok(SocketAddress::new(address, port))
}