relay compiles

Author: divagant-martian

iroh-relay/src/client.rs

@@ -36,9 +36,9 @@ use tracing::{debug, error, event, info_span, trace, warn, Instrument, Level};
 use url::Url;
 
 use crate::{
-    codec::DerpCodec,
     defaults::timeouts::*,
     http::{Protocol, RELAY_PATH},
+    protos::relay::DerpCodec,
     RelayUrl,
 };
 

iroh-relay/src/client/conn.rs

@@ -30,11 +30,11 @@ use tracing::{debug, info_span, trace, Instrument};
 
 use crate::{
     client::streams::{MaybeTlsStreamReader, MaybeTlsStreamWriter},
-    codec::{
+    defaults::timeouts::CLIENT_RECV_TIMEOUT,
+    protos::relay::{
         write_frame, ClientInfo, DerpCodec, Frame, MAX_PACKET_SIZE, PER_CLIENT_READ_QUEUE_DEPTH,
         PER_CLIENT_SEND_QUEUE_DEPTH, PROTOCOL_VERSION,
     },
-    defaults::timeouts::CLIENT_RECV_TIMEOUT,
 };
 
 impl PartialEq for Conn {
@@ -366,7 +366,8 @@ impl ConnBuilder {
             version: PROTOCOL_VERSION,
         };
         debug!("server_handshake: sending client_key: {:?}", &client_info);
-        crate::codec::send_client_key(&mut self.writer, &self.secret_key, &client_info).await?;
+        crate::protos::relay::send_client_key(&mut self.writer, &self.secret_key, &client_info)
+            .await?;
 
         // TODO: add some actual configuration
         let rate_limiter = RateLimiter::new(0, 0)?;

iroh-relay/src/dns.rs

@@ -0,0 +1,69 @@
+use std::net::{IpAddr, Ipv6Addr};
+
+use anyhow::Result;
+use hickory_resolver::{AsyncResolver, TokioAsyncResolver};
+use once_cell::sync::Lazy;
+
+/// The DNS resolver type used throughout `iroh-net`.
+pub(crate) type DnsResolver = TokioAsyncResolver;
+
+static DNS_RESOLVER: Lazy<TokioAsyncResolver> =
+    Lazy::new(|| create_default_resolver().expect("unable to create DNS resolver"));
+
+/// Get a reference to the default DNS resolver.
+///
+/// The default resolver can be cheaply cloned and is shared throughout the running process.
+/// It is configured to use the system's DNS configuration.
+pub fn default_resolver() -> &'static DnsResolver {
+    &DNS_RESOLVER
+}
+
+/// Get the DNS resolver used within iroh-net.
+pub fn resolver() -> &'static TokioAsyncResolver {
+    Lazy::force(&DNS_RESOLVER)
+}
+
+/// Deprecated IPv6 site-local anycast addresses still configured by windows.
+///
+/// Windows still configures these site-local addresses as soon even as an IPv6 loopback
+/// interface is configured.  We do not want to use these DNS servers, the chances of them
+/// being usable are almost always close to zero, while the chance of DNS configuration
+/// **only** relying on these servers and not also being configured normally are also almost
+/// zero.  The chance of the DNS resolver accidentally trying one of these and taking a
+/// bunch of timeouts to figure out they're no good are on the other hand very high.
+const WINDOWS_BAD_SITE_LOCAL_DNS_SERVERS: [IpAddr; 3] = [
+    IpAddr::V6(Ipv6Addr::new(0xfec0, 0, 0, 0xffff, 0, 0, 0, 1)),
+    IpAddr::V6(Ipv6Addr::new(0xfec0, 0, 0, 0xffff, 0, 0, 0, 2)),
+    IpAddr::V6(Ipv6Addr::new(0xfec0, 0, 0, 0xffff, 0, 0, 0, 3)),
+];
+
+/// Get resolver to query MX records.
+///
+/// We first try to read the system's resolver from `/etc/resolv.conf`.
+/// This does not work at least on some Androids, therefore we fallback
+/// to the default `ResolverConfig` which uses eg. to google's `8.8.8.8` or `8.8.4.4`.
+fn create_default_resolver() -> Result<TokioAsyncResolver> {
+    let (system_config, mut options) =
+        hickory_resolver::system_conf::read_system_conf().unwrap_or_default();
+
+    // Copy all of the system config, but strip the bad windows nameservers.  Unfortunately
+    // there is no easy way to do this.
+    let mut config = hickory_resolver::config::ResolverConfig::new();
+    if let Some(name) = system_config.domain() {
+        config.set_domain(name.clone());
+    }
+    for name in system_config.search() {
+        config.add_search(name.clone());
+    }
+    for nameserver_cfg in system_config.name_servers() {
+        if !WINDOWS_BAD_SITE_LOCAL_DNS_SERVERS.contains(&nameserver_cfg.socket_addr.ip()) {
+            config.add_name_server(nameserver_cfg.clone());
+        }
+    }
+
+    // see [`ResolverExt::lookup_ipv4_ipv6`] for info on why we avoid `LookupIpStrategy::Ipv4AndIpv6`
+    options.ip_strategy = hickory_resolver::config::LookupIpStrategy::Ipv4thenIpv6;
+
+    let resolver = AsyncResolver::tokio(config, options);
+    Ok(resolver)
+}

iroh-relay/src/lib.rs

@@ -10,10 +10,11 @@
 #![deny(missing_docs, rustdoc::broken_intra_doc_links)]
 
 pub(crate) mod client;
-pub(crate) mod codec;
 mod defaults;
+mod dns;
 pub mod http;
 mod map;
+pub mod protos;
 #[cfg(feature = "iroh-relay")]
 #[cfg_attr(iroh_docsrs, doc(cfg(feature = "iroh-relay")))]
 pub mod server;
@@ -36,6 +37,6 @@ pub use self::{
         Client as HttpClient, ClientBuilder as HttpClientBuilder, ClientError as HttpClientError,
         ClientReceiver as HttpClientReceiver,
     },
-    codec::MAX_PACKET_SIZE,
     map::{RelayMap, RelayMode, RelayNode},
+    protos::relay::MAX_PACKET_SIZE,
 };

iroh-relay/src/protos.rs

@@ -0,0 +1,5 @@
+//! Protocols used by the iroh-relay
+
+pub mod disco;
+pub mod relay;
+pub mod stun;

iroh-relay/src/protos/disco.rs

@@ -0,0 +1,20 @@
+//! This module exports [`looks_like_disco_wrapper`] as the only disco-related relay
+//! funcionality.
+//!
+//! Despite the relay not being able to read disco messages by design, it does attempt to
+//! identify this trafic to ensure hole-punching messages are not lost do to congestion.
+
+/// The 6 byte header of all discovery messages.
+pub const MAGIC: &str = "TS💬"; // 6 bytes: 0x54 53 f0 9f 92 ac
+pub(crate) const MAGIC_LEN: usize = MAGIC.as_bytes().len();
+pub(crate) const KEY_LEN: usize = 32;
+
+const MESSAGE_HEADER_LEN: usize = MAGIC_LEN + KEY_LEN;
+/// Reports whether p looks like it's a packet containing an encrypted disco message.
+pub fn looks_like_disco_wrapper(p: &[u8]) -> bool {
+    if p.len() < MESSAGE_HEADER_LEN {
+        return false;
+    }
+
+    &p[..MAGIC_LEN] == MAGIC.as_bytes()
+}

iroh-relay/src/codec.rs renamed to iroh-relay/src/protos/relay.rs

@@ -1,3 +1,5 @@
+//! This module implements the relaying protocol used the [`crate::server`] and [`crate::client`].
+
 use std::time::Duration;
 
 use anyhow::{bail, ensure};
@@ -26,14 +28,14 @@ const MAGIC: &str = "RELAY🔑";
 
 #[cfg(feature = "iroh-relay")]
 #[cfg_attr(iroh_docsrs, doc(cfg(feature = "iroh-relay")))]
-pub(super) const KEEP_ALIVE: Duration = Duration::from_secs(60);
+pub(crate) const KEEP_ALIVE: Duration = Duration::from_secs(60);
 // TODO: what should this be?
 #[cfg(feature = "iroh-relay")]
 #[cfg_attr(iroh_docsrs, doc(cfg(feature = "iroh-relay")))]
-pub(super) const SERVER_CHANNEL_SIZE: usize = 1024 * 100;
+pub(crate) const SERVER_CHANNEL_SIZE: usize = 1024 * 100;
 /// The number of packets buffered for sending per client
-pub(super) const PER_CLIENT_SEND_QUEUE_DEPTH: usize = 512; //32;
-pub(super) const PER_CLIENT_READ_QUEUE_DEPTH: usize = 512;
+pub(crate) const PER_CLIENT_SEND_QUEUE_DEPTH: usize = 512; //32;
+pub(crate) const PER_CLIENT_READ_QUEUE_DEPTH: usize = 512;
 
 /// ProtocolVersion is bumped whenever there's a wire-incompatible change.
 ///  - version 1 (zero on wire): consistent box headers, in use by employee dev nodes a bit
@@ -47,7 +49,7 @@ pub(super) const PER_CLIENT_READ_QUEUE_DEPTH: usize = 512;
 /// The server will error on that connection if a client sends one of these frames.
 /// This materially affects the handshake protocol, and so relay nodes on version 3 will be unable to communicate
 /// with nodes running earlier protocol versions.
-pub(super) const PROTOCOL_VERSION: usize = 3;
+pub(crate) const PROTOCOL_VERSION: usize = 3;
 
 ///
 /// Protocol flow:
@@ -129,7 +131,7 @@ pub(crate) struct ClientInfo {
 /// Ignores the timeout if `None`
 ///
 /// Does not flush.
-pub(super) async fn write_frame<S: Sink<Frame, Error = std::io::Error> + Unpin>(
+pub(crate) async fn write_frame<S: Sink<Frame, Error = std::io::Error> + Unpin>(
     mut writer: S,
     frame: Frame,
     timeout: Option<Duration>,
@@ -171,7 +173,7 @@ pub(crate) async fn send_client_key<S: Sink<Frame, Error = std::io::Error> + Unp
 // TODO(@divma): weird I had to change this
 // #[cfg(feature = "iroh-relay")]
 // #[cfg_attr(iroh_docsrs, doc(cfg(feature = "iroh-relay")))]
-pub(super) async fn recv_client_key<S: Stream<Item = anyhow::Result<Frame>> + Unpin>(
+pub(crate) async fn recv_client_key<S: Stream<Item = anyhow::Result<Frame>> + Unpin>(
     stream: S,
 ) -> anyhow::Result<(PublicKey, ClientInfo)> {
     use anyhow::Context;
@@ -244,7 +246,7 @@ pub(crate) enum Frame {
 }
 
 impl Frame {
-    pub(super) fn typ(&self) -> FrameType {
+    pub(crate) fn typ(&self) -> FrameType {
         match self {
             Frame::ClientInfo { .. } => FrameType::ClientInfo,
             Frame::SendPacket { .. } => FrameType::SendPacket,
@@ -260,7 +262,7 @@ impl Frame {
     }
 
     /// Serialized length (without the frame header)
-    pub(super) fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         match self {
             Frame::ClientInfo {
                 client_public_key: _,
@@ -543,7 +545,7 @@ impl Encoder<Frame> for DerpCodec {
 // TODO(@divma): what's going on
 // #[cfg(feature = "iroh-relay")]
 // #[cfg_attr(iroh_docsrs, doc(cfg(feature = "iroh-relay")))]
-pub(super) async fn recv_frame<S: Stream<Item = anyhow::Result<Frame>> + Unpin>(
+pub(crate) async fn recv_frame<S: Stream<Item = anyhow::Result<Frame>> + Unpin>(
     frame_type: FrameType,
     mut stream: S,
 ) -> anyhow::Result<Frame> {