initial import of main veilid core

veilid-core/src/rpc_processor/coders/address.rs

@@ -0,0 +1,69 @@
+use crate::xx::*;
+use crate::*;
+use core::convert::TryInto;
+use rpc_processor::*;
+
+pub fn encode_address(
+    address: &Address,
+    builder: &mut veilid_capnp::address::Builder,
+) -> Result<(), RPCError> {
+    match address {
+        Address::IPV4(v4) => {
+            let mut v4b = builder.reborrow().init_ipv4();
+            v4b.set_addr(u32::from_be_bytes(v4.octets()));
+        }
+        Address::IPV6(v6) => {
+            let mut v6b = builder.reborrow().init_ipv6();
+            v6b.set_addr0(u32::from_be_bytes(
+                v6.octets()[0..4]
+                    .try_into()
+                    .expect("slice with incorrect length"),
+            ));
+            v6b.set_addr1(u32::from_be_bytes(
+                v6.octets()[4..8]
+                    .try_into()
+                    .expect("slice with incorrect length"),
+            ));
+            v6b.set_addr2(u32::from_be_bytes(
+                v6.octets()[8..12]
+                    .try_into()
+                    .expect("slice with incorrect length"),
+            ));
+            v6b.set_addr3(u32::from_be_bytes(
+                v6.octets()[12..16]
+                    .try_into()
+                    .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(())
+}
+
+pub fn decode_address(reader: &veilid_capnp::address::Reader) -> Result<Address, RPCError> {
+    match reader.reborrow().which() {
+        Ok(veilid_capnp::address::Which::Ipv4(Ok(v4))) => {
+            let v4b = v4.get_addr().to_be_bytes();
+            Ok(Address::IPV4(Ipv4Addr::new(v4b[0], v4b[1], v4b[2], v4b[3])))
+        }
+        Ok(veilid_capnp::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(Address::IPV6(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],
+            ])))
+        }
+        Ok(veilid_capnp::address::Which::Hostname(Ok(tr))) => Ok(Address::Hostname(tr.to_owned())),
+        _ => Err(rpc_error_internal("invalid address type")),
+    }
+}

veilid-core/src/rpc_processor/coders/dial_info.rs

@@ -0,0 +1,101 @@
+use crate::xx::*;
+use crate::*;
+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))) => {
+            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))
+        }
+        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))
+        }
+        Ok(veilid_capnp::dial_info::Which::Ws(Ok(ws))) => {
+            let fqdn = ws
+                .get_fqdn()
+                .map_err(map_error_internal!("missing ws fqdn"))?;
+            let port = ws.get_port();
+            let path = ws
+                .get_path()
+                .map_err(map_error_internal!("missing ws path"))?;
+            Ok(DialInfo::ws(fqdn.to_owned(), port, path.to_owned()))
+        }
+        Ok(veilid_capnp::dial_info::Which::Wss(Ok(wss))) => {
+            let fqdn = wss
+                .get_fqdn()
+                .map_err(map_error_internal!("missing wss fqdn"))?;
+            let port = wss.get_port();
+            let path = wss
+                .get_path()
+                .map_err(map_error_internal!("missing wss path"))?;
+            Ok(DialInfo::wss(fqdn.to_owned(), port, path.to_owned()))
+        }
+        _ => Err(rpc_error_internal("invalid dial info type")),
+    }
+}
+
+pub fn encode_dial_info(
+    dial_info: &DialInfo,
+    builder: &mut veilid_capnp::dial_info::Builder,
+) -> Result<(), RPCError> {
+    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);
+        }
+        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);
+        }
+        DialInfo::WS(ws) => {
+            let mut di_ws_builder = builder.reborrow().init_ws();
+            let mut fqdnb = di_ws_builder.reborrow().init_fqdn(
+                ws.fqdn
+                    .len()
+                    .try_into()
+                    .map_err(map_error_internal!("fqdn too long"))?,
+            );
+            fqdnb.push_str(ws.fqdn.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());
+        }
+        DialInfo::WSS(wss) => {
+            let mut di_wss_builder = builder.reborrow().init_wss();
+            let mut fqdnb = di_wss_builder.reborrow().init_fqdn(
+                wss.fqdn
+                    .len()
+                    .try_into()
+                    .map_err(map_error_internal!("fqdn too long"))?,
+            );
+            fqdnb.push_str(wss.fqdn.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());
+        }
+    };
+    Ok(())
+}

veilid-core/src/rpc_processor/coders/mod.rs

@@ -0,0 +1,21 @@
+mod address;
+mod dial_info;
+mod node_dial_info_single;
+mod node_info;
+mod nonce;
+mod peer_info;
+mod private_safety_route;
+mod public_key;
+mod sender_info;
+mod socket_address;
+
+pub use address::*;
+pub use dial_info::*;
+pub use node_dial_info_single::*;
+pub use node_info::*;
+pub use nonce::*;
+pub use peer_info::*;
+pub use private_safety_route::*;
+pub use public_key::*;
+pub use sender_info::*;
+pub use socket_address::*;

veilid-core/src/rpc_processor/coders/node_dial_info_single.rs

@@ -0,0 +1,29 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_node_dial_info_single(
+    ndis: &NodeDialInfoSingle,
+    builder: &mut veilid_capnp::node_dial_info_single::Builder,
+) -> Result<(), RPCError> {
+    let mut ni_builder = builder.reborrow().init_node_id();
+    encode_public_key(&ndis.node_id.key, &mut ni_builder)?;
+    let mut di_builder = builder.reborrow().init_dial_info();
+    encode_dial_info(&ndis.dial_info, &mut di_builder)?;
+    Ok(())
+}
+
+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!(
+        "invalid public key in node_dial_info_single"
+    ))?);
+    let dial_info = decode_dial_info(&reader.get_dial_info().map_err(map_error_internal!(
+        "invalid dial_info in node_dial_info_single"
+    ))?)?;
+
+    Ok(NodeDialInfoSingle {
+        node_id: NodeId::new(node_id),
+        dial_info: dial_info,
+    })
+}

veilid-core/src/rpc_processor/coders/node_info.rs

@@ -0,0 +1,39 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_node_info(
+    node_info: &NodeInfo,
+    builder: &mut veilid_capnp::node_info::Builder,
+) -> Result<(), RPCError> {
+    builder.set_can_route(node_info.can_route);
+    builder.set_will_route(node_info.will_route);
+
+    builder.set_can_tunnel(node_info.can_tunnel);
+    builder.set_will_tunnel(node_info.will_tunnel);
+
+    builder.set_can_signal_lease(node_info.can_signal_lease);
+    builder.set_will_signal_lease(node_info.will_signal_lease);
+
+    builder.set_can_relay_lease(node_info.can_relay_lease);
+    builder.set_will_relay_lease(node_info.will_relay_lease);
+
+    builder.set_can_validate_dial_info(node_info.can_validate_dial_info);
+    builder.set_will_validate_dial_info(node_info.will_validate_dial_info);
+
+    Ok(())
+}
+
+pub fn decode_node_info(reader: &veilid_capnp::node_info::Reader) -> Result<NodeInfo, RPCError> {
+    Ok(NodeInfo {
+        can_route: reader.reborrow().get_can_route(),
+        will_route: reader.reborrow().get_will_route(),
+        can_tunnel: reader.reborrow().get_can_tunnel(),
+        will_tunnel: reader.reborrow().get_will_tunnel(),
+        can_signal_lease: reader.reborrow().get_can_signal_lease(),
+        will_signal_lease: reader.reborrow().get_will_signal_lease(),
+        can_relay_lease: reader.reborrow().get_can_relay_lease(),
+        will_relay_lease: reader.reborrow().get_will_relay_lease(),
+        can_validate_dial_info: reader.reborrow().get_can_validate_dial_info(),
+        will_validate_dial_info: reader.reborrow().get_will_validate_dial_info(),
+    })
+}

veilid-core/src/rpc_processor/coders/nonce.rs

@@ -0,0 +1,33 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_nonce(
+    nonce: &Nonce,
+    builder: &mut veilid_capnp::x_cha_cha20_poly1305_nonce::Builder,
+) {
+    builder.set_u0(u64::from_be_bytes(
+        nonce[0..8].try_into().expect("slice with incorrect length"),
+    ));
+    builder.set_u1(u64::from_be_bytes(
+        nonce[8..16]
+            .try_into()
+            .expect("slice with incorrect length"),
+    ));
+    builder.set_u2(u64::from_be_bytes(
+        nonce[16..24]
+            .try_into()
+            .expect("slice with incorrect length"),
+    ));
+}
+
+pub fn decode_nonce(reader: &veilid_capnp::x_cha_cha20_poly1305_nonce::Reader) -> Nonce {
+    let u0 = reader.get_u0().to_be_bytes();
+    let u1 = reader.get_u1().to_be_bytes();
+    let u2 = reader.get_u2().to_be_bytes();
+
+    [
+        u0[0], u0[1], u0[2], u0[3], u0[4], u0[5], u0[6], u0[7], // u0
+        u1[0], u1[1], u1[2], u1[3], u1[4], u1[5], u1[6], u1[7], // u1
+        u2[0], u2[1], u2[2], u2[3], u2[4], u2[5], u2[6], u2[7], // u2
+    ]
+}

veilid-core/src/rpc_processor/coders/peer_info.rs

@@ -0,0 +1,50 @@
+use crate::xx::*;
+use crate::*;
+use core::convert::TryInto;
+use rpc_processor::*;
+
+pub fn encode_peer_info(
+    peer_info: &PeerInfo,
+    builder: &mut veilid_capnp::peer_info::Builder,
+) -> Result<(), RPCError> {
+    //
+    let mut nid_builder = builder.reborrow().init_node_id();
+    encode_public_key(&peer_info.node_id.key, &mut nid_builder)?;
+    let mut dil_builder = builder.reborrow().init_dial_info_list(
+        peer_info
+            .dial_infos
+            .len()
+            .try_into()
+            .map_err(map_error_internal!("too many dial infos in peer info"))?,
+    );
+
+    for idx in 0..peer_info.dial_infos.len() {
+        let mut di_builder = dil_builder.reborrow().get(idx as u32);
+        encode_dial_info(&peer_info.dial_infos[idx], &mut di_builder)?;
+    }
+    Ok(())
+}
+
+pub fn decode_peer_info(reader: &veilid_capnp::peer_info::Reader) -> Result<PeerInfo, RPCError> {
+    let nid_reader = reader
+        .reborrow()
+        .get_node_id()
+        .map_err(map_error_capnp_error!())?;
+    let dil_reader = reader
+        .reborrow()
+        .get_dial_info_list()
+        .map_err(map_error_capnp_error!())?;
+    let mut dial_infos = Vec::<DialInfo>::with_capacity(
+        dil_reader
+            .len()
+            .try_into()
+            .map_err(map_error_internal!("too many dial infos"))?,
+    );
+    for di in dil_reader.iter() {
+        dial_infos.push(decode_dial_info(&di)?)
+    }
+    Ok(PeerInfo {
+        node_id: NodeId::new(decode_public_key(&nid_reader)),
+        dial_infos: dial_infos,
+    })
+}

veilid-core/src/rpc_processor/coders/private_safety_route.rs

@@ -0,0 +1,212 @@
+use crate::xx::*;
+use crate::*;
+use core::convert::TryInto;
+use rpc_processor::*;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, Debug)]
+pub struct RouteHopData {
+    pub nonce: Nonce,
+    pub blob: Vec<u8>,
+}
+
+#[derive(Clone, Debug)]
+pub struct RouteHop {
+    pub dial_info: NodeDialInfoSingle,
+    pub next_hop: Option<RouteHopData>,
+}
+
+#[derive(Clone, Debug)]
+pub struct PrivateRoute {
+    pub public_key: DHTKey,
+    pub hop_count: u8,
+    pub hops: Option<RouteHop>,
+}
+
+#[derive(Clone, Debug)]
+pub enum SafetyRouteHops {
+    Data(RouteHopData),
+    Private(PrivateRoute),
+}
+
+#[derive(Clone, Debug)]
+pub struct SafetyRoute {
+    pub public_key: DHTKey,
+    pub hop_count: u8,
+    pub hops: SafetyRouteHops,
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub fn encode_route_hop_data(
+    route_hop_data: &RouteHopData,
+    builder: &mut veilid_capnp::route_hop_data::Builder,
+) -> Result<(), RPCError> {
+    //
+    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_internal!("invalid blob length in route hop data"))?,
+    );
+    blob_builder.copy_from_slice(route_hop_data.blob.as_slice());
+    Ok(())
+}
+
+pub fn encode_route_hop(
+    route_hop: &RouteHop,
+    builder: &mut veilid_capnp::route_hop::Builder,
+) -> Result<(), RPCError> {
+    encode_node_dial_info_single(
+        &route_hop.dial_info,
+        &mut builder.reborrow().init_dial_info(),
+    )?;
+    if let Some(rhd) = &route_hop.next_hop {
+        let mut rhd_builder = builder.reborrow().init_next_hop();
+        encode_route_hop_data(&rhd, &mut rhd_builder)?;
+    }
+    Ok(())
+}
+
+pub fn encode_private_route(
+    private_route: &PrivateRoute,
+    builder: &mut veilid_capnp::private_route::Builder,
+) -> Result<(), RPCError> {
+    encode_public_key(
+        &private_route.public_key,
+        &mut builder.reborrow().init_public_key(),
+    )?;
+    builder.set_hop_count(private_route.hop_count);
+    if let Some(rh) = &private_route.hops {
+        let mut rh_builder = builder.reborrow().init_first_hop();
+        encode_route_hop(&rh, &mut rh_builder)?;
+    };
+
+    Ok(())
+}
+
+pub fn encode_safety_route(
+    safety_route: &SafetyRoute,
+    builder: &mut veilid_capnp::safety_route::Builder,
+) -> Result<(), RPCError> {
+    encode_public_key(
+        &safety_route.public_key,
+        &mut builder.reborrow().init_public_key(),
+    )?;
+    builder.set_hop_count(safety_route.hop_count);
+    let h_builder = builder.reborrow().init_hops();
+    match &safety_route.hops {
+        SafetyRouteHops::Data(rhd) => {
+            let mut rhd_builder = h_builder.init_data();
+            encode_route_hop_data(&rhd, &mut rhd_builder)?;
+        }
+        SafetyRouteHops::Private(pr) => {
+            let mut pr_builder = h_builder.init_private();
+            encode_private_route(&pr, &mut pr_builder)?;
+        }
+    };
+
+    Ok(())
+}
+
+pub fn decode_route_hop_data(
+    reader: &veilid_capnp::route_hop_data::Reader,
+) -> Result<RouteHopData, RPCError> {
+    let nonce = decode_nonce(
+        &reader
+            .reborrow()
+            .get_nonce()
+            .map_err(map_error_internal!("invalid nonce in route hop data"))?,
+    );
+
+    let blob = reader
+        .reborrow()
+        .get_blob()
+        .map_err(map_error_internal!("invalid blob in route hop data"))?
+        .to_vec();
+
+    Ok(RouteHopData {
+        nonce: nonce,
+        blob: blob,
+    })
+}
+
+pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<RouteHop, RPCError> {
+    let dial_info = decode_node_dial_info_single(
+        &reader
+            .reborrow()
+            .get_dial_info()
+            .map_err(map_error_internal!("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"))?;
+        Some(decode_route_hop_data(&rhd_reader)?)
+    } else {
+        None
+    };
+
+    Ok(RouteHop {
+        dial_info: dial_info,
+        next_hop: next_hop,
+    })
+}
+
+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_internal!("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"))?;
+        Some(decode_route_hop(&rh_reader)?)
+    } else {
+        None
+    };
+
+    Ok(PrivateRoute {
+        public_key: public_key,
+        hop_count: hop_count,
+        hops: hops,
+    })
+}
+
+pub fn decode_safety_route(
+    reader: &veilid_capnp::safety_route::Reader,
+) -> Result<SafetyRoute, RPCError> {
+    let public_key = decode_public_key(
+        &reader
+            .get_public_key()
+            .map_err(map_error_internal!("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))) => {
+            SafetyRouteHops::Data(decode_route_hop_data(&rhd_reader)?)
+        }
+        Ok(veilid_capnp::safety_route::hops::Which::Private(Ok(pr_reader))) => {
+            SafetyRouteHops::Private(decode_private_route(&pr_reader)?)
+        }
+        _ => {
+            return Err(rpc_error_internal("invalid hops in safety route"));
+        }
+    };
+
+    Ok(SafetyRoute {
+        public_key: public_key,
+        hop_count: hop_count,
+        hops: hops,
+    })
+}

veilid-core/src/rpc_processor/coders/public_key.rs

@@ -0,0 +1,49 @@
+use crate::dht::*;
+use crate::*;
+use core::convert::TryInto;
+use rpc_processor::*;
+
+pub fn decode_public_key(public_key: &veilid_capnp::curve25519_public_key::Reader) -> key::DHTKey {
+    let u0 = public_key.get_u0().to_be_bytes();
+    let u1 = public_key.get_u1().to_be_bytes();
+    let u2 = public_key.get_u2().to_be_bytes();
+    let u3 = public_key.get_u3().to_be_bytes();
+
+    let mut x: [u8; 32] = Default::default();
+    x[0..8].copy_from_slice(&u0);
+    x[8..16].copy_from_slice(&u1);
+    x[16..24].copy_from_slice(&u2);
+    x[24..32].copy_from_slice(&u3);
+
+    key::DHTKey::new(x)
+}
+
+pub fn encode_public_key(
+    key: &key::DHTKey,
+    builder: &mut veilid_capnp::curve25519_public_key::Builder,
+) -> Result<(), RPCError> {
+    if !key.valid {
+        return Err(rpc_error_internal("invalid key"));
+    }
+    builder.set_u0(u64::from_be_bytes(
+        key.bytes[0..8]
+            .try_into()
+            .map_err(map_error_internal!("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"))?,
+    ));
+    builder.set_u2(u64::from_be_bytes(
+        key.bytes[16..24]
+            .try_into()
+            .map_err(map_error_internal!("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"))?,
+    ));
+    Ok(())
+}

veilid-core/src/rpc_processor/coders/sender_info.rs

@@ -0,0 +1,34 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_sender_info(
+    sender_info: &SenderInfo,
+    builder: &mut veilid_capnp::sender_info::Builder,
+) -> Result<(), RPCError> {
+    if let Some(socket_address) = &sender_info.socket_address {
+        let mut sab = builder.reborrow().init_socket_address();
+        encode_socket_address(socket_address, &mut sab)?;
+    }
+    Ok(())
+}
+
+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"));
+    }
+    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"))?,
+        )?)
+    } else {
+        None
+    };
+    Ok(SenderInfo {
+        socket_address: socket_address,
+    })
+}

veilid-core/src/rpc_processor/coders/socket_address.rs

@@ -0,0 +1,72 @@
+use crate::xx::*;
+use crate::*;
+use core::convert::TryInto;
+use rpc_processor::*;
+
+pub fn encode_socket_address(
+    address: &SocketAddr,
+    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());
+        }
+    };
+    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")),
+    }
+}