dataplane, transport: node keys -> peer ids

Cargo.toml

@@ -12,9 +12,9 @@ members = [
     "ts_control_noise",
     "ts_control_serde",
     "ts_dataplane",
+    "ts_derp",
     "ts_devtools",
     "ts_disco_protocol",
-    "ts_disco_protocol",
     "ts_dynbitset",
     "ts_elixir/native/ts_elixir",
     "ts_ffi",
@@ -38,7 +38,6 @@ members = [
     "ts_time",
     "ts_tls_util",
     "ts_transport",
-    "ts_transport_derp",
     "ts_transport_tun",
     "ts_underlay_router",
     "ts_tunnel",
@@ -116,6 +115,7 @@ ts_control = { path = "ts_control", version = "0.2.0" }
 ts_control_noise = { path = "ts_control_noise", version = "0.2.0" }
 ts_control_serde = { path = "ts_control_serde", version = "0.2.0" }
 ts_dataplane = { path = "ts_dataplane", version = "0.2.0" }
+ts_derp = { path = "ts_derp", version = "0.2.0" }
 ts_disco_protocol = { path = "ts_disco_protocol", version = "0.2.0" }
 ts_dynbitset = { path = "ts_dynbitset", version = "0.2.0" }
 ts_hexdump = { path = "ts_hexdump", version = "0.2.0" }
@@ -137,7 +137,6 @@ ts_runtime = { path = "ts_runtime", version = "0.2.0" }
 ts_test_util = { path = "ts_test_util" }
 ts_time = { path = "ts_time", version = "0.2.0" }
 ts_transport = { path = "ts_transport", version = "0.2.0" }
-ts_transport_derp = { path = "ts_transport_derp", version = "0.2.0" }
 ts_transport_tun = { path = "ts_transport_tun", version = "0.2.0" }
 ts_underlay_router = { path = "ts_underlay_router", version = "0.2.0" }
 ts_tunnel = { path = "ts_tunnel", version = "0.2.0" }

ts_cli_util/Cargo.toml

@@ -16,7 +16,7 @@ rust-version.workspace = true
 tailscale.workspace = true
 ts_control.workspace = true
 ts_netcheck.workspace = true
-ts_transport_derp.workspace = true
+ts_derp.workspace = true
 
 # Unconditionally required dependencies.
 cfg-if.workspace = true

ts_cli_util/src/lib.rs

@@ -5,8 +5,8 @@ use std::sync::Arc;
 use futures_util::{Stream, StreamExt};
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::{Layer, layer::SubscriberExt, util::SubscriberInitExt};
+use ts_derp::{RegionId, ServerConnInfo};
 use ts_netcheck::RegionResult;
-use ts_transport_derp::{RegionId, ServerConnInfo};
 
 /// Result with a boxed [`core::error::Error`] trait object.
 pub type Result<T> = core::result::Result<T, Box<dyn core::error::Error + Send + Sync + 'static>>;

ts_control/Cargo.toml

@@ -24,7 +24,7 @@ ts_packet.workspace = true
 ts_packetfilter.workspace = true
 ts_packetfilter_state.workspace = true
 ts_tls_util.workspace = true
-ts_transport_derp.workspace = true
+ts_derp.workspace = true
 
 # Unconditionally required dependencies.
 bytes.workspace = true
@@ -51,7 +51,7 @@ default = ["async_tokio"]
 async_tokio = ["dep:futures-util", "dep:tokio", "dep:tokio-stream"]
 
 # Allow derp connections to be made without verifying TLS certs. Only for use in tests.
-insecure-derp = ["ts_transport_derp/insecure-for-tests"]
+insecure-derp = ["ts_derp/insecure-for-tests"]
 # Allow control keys to be fetched over plain HTTP1 without TLS. Only for use in tests.
 insecure-keyfetch = []
 

ts_control/src/derp.rs

@@ -1,17 +1,17 @@
 use alloc::collections::BTreeMap;
 
-use ts_transport_derp::TlsValidationConfig;
+use ts_derp::TlsValidationConfig;
 
-/// The full derp state, a map of [`ts_transport_derp::RegionId`]s to [`Region`]s.
-pub type Map = BTreeMap<ts_transport_derp::RegionId, Region>;
+/// The full derp state, a map of [`ts_derp::RegionId`]s to [`Region`]s.
+pub type Map = BTreeMap<ts_derp::RegionId, Region>;
 
-/// Convert a derp map from the [`ts_control_serde`] representation to the [`ts_transport_derp`]
+/// Convert a derp map from the [`ts_control_serde`] representation to the [`ts_derp`]
 /// representation.
 pub fn convert_derp_map(
     derp_map: &ts_control_serde::DerpMap<'_>,
-) -> impl Iterator<Item = (ts_transport_derp::RegionId, Region)> {
+) -> impl Iterator<Item = (ts_derp::RegionId, Region)> {
     derp_map.regions.iter().map(|(id, region)| {
-        let id = ts_transport_derp::RegionId((*id).into());
+        let id = ts_derp::RegionId((*id).into());
         let region: Region = region.into();
 
         (id, region)
@@ -22,10 +22,10 @@ pub fn convert_derp_map(
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Region {
     /// The info for this region.
-    pub info: ts_transport_derp::RegionInfo,
+    pub info: ts_derp::RegionInfo,
 
     /// Servers in this region.
-    pub servers: Vec<ts_transport_derp::ServerConnInfo>,
+    pub servers: Vec<ts_derp::ServerConnInfo>,
 }
 
 impl From<&ts_control_serde::DerpRegion<'_>> for Region {
@@ -37,15 +37,15 @@ impl From<&ts_control_serde::DerpRegion<'_>> for Region {
     }
 }
 
-fn region_info(region: &ts_control_serde::DerpRegion) -> ts_transport_derp::RegionInfo {
-    ts_transport_derp::RegionInfo {
+fn region_info(region: &ts_control_serde::DerpRegion) -> ts_derp::RegionInfo {
+    ts_derp::RegionInfo {
         name: region.name.to_string(),
         code: region.code.to_string(),
         no_measure_no_home: region.no_measure_no_home,
     }
 }
 
-fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerConnInfo {
+fn server(server: &ts_control_serde::DerpServer) -> ts_derp::ServerConnInfo {
     const DEFAULT_TLS_PORT: u16 = 443;
 
     let https_port = match server.derp_port {
@@ -62,7 +62,7 @@ fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerCon
         tls_config = TlsValidationConfig::InsecureForTests;
     };
 
-    ts_transport_derp::ServerConnInfo {
+    ts_derp::ServerConnInfo {
         hostname: server.hostname.to_string(),
         https_port,
         stun_port: server.stun_port.into(),
@@ -77,13 +77,13 @@ fn server(server: &ts_control_serde::DerpServer) -> ts_transport_derp::ServerCon
     }
 }
 
-fn convert_ip_usage<T>(ip: ts_control_serde::DerpIpUsage<T>) -> ts_transport_derp::IpUsage<T>
+fn convert_ip_usage<T>(ip: ts_control_serde::DerpIpUsage<T>) -> ts_derp::IpUsage<T>
 where
     T: Copy,
 {
     match ip {
-        ts_control_serde::DerpIpUsage::Disable => ts_transport_derp::IpUsage::Disable,
-        ts_control_serde::DerpIpUsage::UseDns => ts_transport_derp::IpUsage::UseDns,
-        ts_control_serde::DerpIpUsage::FixedAddr(ip) => ts_transport_derp::IpUsage::FixedAddr(ip),
+        ts_control_serde::DerpIpUsage::Disable => ts_derp::IpUsage::Disable,
+        ts_control_serde::DerpIpUsage::UseDns => ts_derp::IpUsage::UseDns,
+        ts_control_serde::DerpIpUsage::FixedAddr(ip) => ts_derp::IpUsage::FixedAddr(ip),
     }
 }

ts_control/src/map_request_builder.rs

@@ -67,7 +67,7 @@ impl<'a> MapRequestBuilder<'a> {
 
     /// Set the [`NetInfo::preferred_derp`] field (inside [`MapRequest::host_info`] ->
     /// [`HostInfo::net_info`]).
-    pub fn preferred_derp(mut self, value: ts_transport_derp::RegionId) -> Self {
+    pub fn preferred_derp(mut self, value: ts_derp::RegionId) -> Self {
         self.net_info_mut().preferred_derp = Some(value.0.into());
         self
     }

ts_control/src/node.rs

@@ -46,7 +46,7 @@ pub struct Node {
     pub underlay_addresses: Vec<SocketAddr>,
 
     /// The DERP region for this node, if known.
-    pub derp_region: Option<ts_transport_derp::RegionId>,
+    pub derp_region: Option<ts_derp::RegionId>,
 }
 
 impl Node {
@@ -155,7 +155,7 @@ impl From<&ts_control_serde::Node<'_>> for Node {
                 .home_derp
                 .or(value.legacy_derp_string)
                 .or_else(|| value.host_info.net_info.as_ref()?.preferred_derp)
-                .map(|x| ts_transport_derp::RegionId(x.into())),
+                .map(|x| ts_derp::RegionId(x.into())),
         }
     }
 }

ts_control/src/tokio/client.rs

@@ -133,7 +133,7 @@ impl AsyncControlClient {
     #[tracing::instrument(skip_all, fields(map_url = %self.map_url(), %region_id), err, level = "trace")]
     pub async fn set_home_region<'c>(
         &mut self,
-        region_id: ts_transport_derp::RegionId,
+        region_id: ts_derp::RegionId,
         latencies: impl IntoIterator<Item = (&'c str, f64)>,
     ) -> Result<(), MapStreamError> {
         tracing::trace!(region = %region_id, "reporting home derp to control server");
@@ -171,7 +171,7 @@ impl AsyncControlClient {
 #[derive(Debug)]
 pub enum Command {
     SetDerpHomeRegion {
-        id: ts_transport_derp::RegionId,
+        id: ts_derp::RegionId,
         latencies: BTreeMap<String, f64>,
     },
 }

ts_dataplane/Cargo.toml

@@ -28,7 +28,9 @@ ts_bart.workspace = true
 
 # Unconditionally required dependencies.
 etherparse = "0.19"
+redb = "4.1"
 tracing.workspace = true
+zerocopy.workspace = true
 
 # Required dependencies for the async_tokio feature.
 tokio = { workspace = true, optional = true, features = ["time", "sync"] }