cleanup: remove mentions of stun

dignifiedquire · dignifiedquire · commit 303dce9c744f · 2025-06-18T16:41:19.000+02:00
diff --git a/docker/Dockerfile b/docker/Dockerfile
@@ -2,7 +2,7 @@ FROM rust:alpine AS chef
 
 RUN update-ca-certificates
 RUN apk add --no-cache musl-dev openssl-dev pkgconfig
-RUN cargo install cargo-chef 
+RUN cargo install cargo-chef
 WORKDIR /iroh
 
 FROM chef AS planner
@@ -40,7 +40,7 @@ RUN chmod +x /iroh-relay
 WORKDIR /
 
 # expose the default ports
-# http, https, stun, metrics
+# http, https, metrics
 EXPOSE  80 443 3478/udp 9090
 ENTRYPOINT ["/iroh-relay"]
 CMD [""]
@@ -62,4 +62,4 @@ WORKDIR /
 # dns, metrics
 EXPOSE 53/udp 9090
 ENTRYPOINT ["/iroh-dns-server"]
-CMD [""]
+CMD [""]
diff --git a/iroh-relay/README.md b/iroh-relay/README.md
@@ -15,10 +15,10 @@ relays, including:
 - Relay Protocol: The protocol used to communicate between relay servers and
   clients
 - Relay Server: A fully-fledged iroh-relay server over HTTP or HTTPS.
-  Optionally will also expose a stun endpoint and metrics.
+  Optionally will also expose a QAD endpoint and metrics.
 - Relay Client: A client for establishing connections to the relay.
 - Server Binary: A CLI for running your own relay server. It can be configured
-  to also offer STUN support and expose metrics.
+  to also expose metrics.
 
 
 Used in [iroh], created with love by the [n0 team](https://n0.computer/).
diff --git a/iroh-relay/src/lib.rs b/iroh-relay/src/lib.rs
@@ -20,10 +20,10 @@
     doc = "- `server`: A fully-fledged iroh-relay server over HTTP or HTTPS."
 )]
 //!
-//!    Optionally will also expose a stun endpoint and metrics. (requires the feature flag `server`)
+//!    Optionally will also expose a QAD endpoint and metrics. (requires the feature flag `server`)
 //! - [`client`]: A client for establishing connections to the relay.
 //! - *Server Binary*: A CLI for running your own relay server. It can be configured to also offer
-//!   STUN support and expose metrics.
+//!   QAD support and expose metrics.
 // Based on tailscale/derp/derp.go
 
 #![cfg_attr(iroh_docsrs, feature(doc_auto_cfg))]
diff --git a/iroh-relay/src/relay_map.rs b/iroh-relay/src/relay_map.rs
@@ -68,7 +68,7 @@ impl FromIterator<RelayNode> for RelayMap {
 impl From<RelayUrl> for RelayMap {
     /// Creates a [`RelayMap`] from a [`RelayUrl`].
     ///
-    /// The [`RelayNode`]s in the [`RelayMap`] will have the default STUN and QUIC address
+    /// The [`RelayNode`]s in the [`RelayMap`] will have the default QUIC address
     /// discovery ports.
     fn from(value: RelayUrl) -> Self {
         Self {
@@ -88,7 +88,7 @@ impl From<RelayNode> for RelayMap {
 impl FromIterator<RelayUrl> for RelayMap {
     /// Creates a [`RelayMap`] from an iterator of [`RelayUrl`].
     ///
-    /// The [`RelayNode`]s in the [`RelayMap`] will have the default STUN and QUIC address
+    /// The [`RelayNode`]s in the [`RelayMap`] will have the default QUIC address
     /// discovery ports.
     fn from_iter<T: IntoIterator<Item = RelayUrl>>(iter: T) -> Self {
         Self {
diff --git a/iroh-relay/src/server.rs b/iroh-relay/src/server.rs
@@ -52,7 +52,7 @@ pub(crate) mod streams;
 pub mod testing;
 
 pub use self::{
-    metrics::{Metrics, RelayMetrics, StunMetrics},
+    metrics::{Metrics, RelayMetrics},
     resolver::{ReloadingResolver, DEFAULT_CERT_RELOAD_INTERVAL},
 };
 
@@ -67,8 +67,14 @@ const INDEX: &[u8] = br#"<html><body>
 </p>
 "#;
 const TLS_HEADERS: [(&str, &str); 2] = [
-    ("Strict-Transport-Security", "max-age=63072000; includeSubDomains"),
-    ("Content-Security-Policy", "default-src 'none'; frame-ancestors 'none'; form-action 'none'; base-uri 'self'; block-all-mixed-content; plugin-types 'none'")
+    (
+        "Strict-Transport-Security",
+        "max-age=63072000; includeSubDomains",
+    ),
+    (
+        "Content-Security-Policy",
+        "default-src 'none'; frame-ancestors 'none'; form-action 'none'; base-uri 'self'; block-all-mixed-content; plugin-types 'none'",
+    ),
 ];
 
 type BytesBody = http_body_util::Full<hyper::body::Bytes>;
@@ -228,9 +234,9 @@ pub enum CertConfig<EC: fmt::Debug, EA: fmt::Debug = EC> {
     Reloading,
 }
 
-/// A running Relay + STUN server.
+/// A running Relay + QAD server.
 ///
-/// This is a full Relay server, including STUN, Relay and various associated HTTP services.
+/// This is a full Relay server, including QAD, Relay and various associated HTTP services.
 ///
 /// Dropping this will stop the server.
 #[derive(Debug)]
@@ -270,9 +276,7 @@ pub struct Server {
 pub enum SpawnError {
     #[snafu(display("Unable to get local address"))]
     LocalAddr { source: std::io::Error },
-    #[snafu(display("Failed to bind STUN listener"))]
-    UdpSocketBind { source: std::io::Error },
-    #[snafu(display("Failed to bind STUN listener"))]
+    #[snafu(display("Failed to bind QAD listener"))]
     QuicSpawn { source: QuicSpawnError },
     #[snafu(display("Failed to parse TLS header"))]
     TlsHeaderParse { source: InvalidHeaderValue },
diff --git a/iroh-relay/src/server/metrics.rs b/iroh-relay/src/server/metrics.rs
@@ -84,28 +84,10 @@ pub struct Metrics {
     // pub average_queue_duration:
 }
 
-/// Metrics tracked for the STUN server.
-#[derive(Debug, Default, MetricsGroup)]
-#[metrics(name = "stun")]
-pub struct StunMetrics {
-    /// Number of STUN requests made to the server.
-    pub requests: Counter,
-    /// Number of successful ipv4 STUN requests served.
-    pub ipv4_success: Counter,
-    /// Number of successful ipv6 STUN requests served.
-    pub ipv6_success: Counter,
-    /// Number of bad requests made to the STUN endpoint.
-    pub bad_requests: Counter,
-    /// Number of STUN requests that end in failure.
-    pub failures: Counter,
-}
-
 /// All metrics tracked in the relay server.
 #[derive(Debug, Default, Clone, MetricsGroupSet)]
 #[metrics(name = "relay")]
 pub struct RelayMetrics {
-    /// Metrics tracked for the STUN server.
-    pub stun: Arc<StunMetrics>,
     /// Metrics tracked for the relay server.
     pub server: Arc<Metrics>,
 }
diff --git a/iroh/README.md b/iroh/README.md
@@ -4,9 +4,9 @@ Iroh is a library to establish direct connectivity between peers.
 It's built on peer-to-peer [QUIC](https://en.wikipedia.org/wiki/QUIC) using both relays and holepunching.
 The main structure for connection is the `Endpoint` entrypoint.
 
-Peer to peer connectivity is established with the help of a _relay server_. The relay server provides Session Traversal Utilities for NAT [(STUN)](https://en.wikipedia.org/wiki/STUN) for the peers. If no direct connection can be established, the connection is relayed via the server.
+Peer to peer connectivity is established with the help of a _relay server_. The relay server provides QUIC NAT traversal (QAD) for the peers. If no direct connection can be established, the connection is relayed via the server.
 
-Peers must know and do verify the PeerID of each other before they can connect. When using a relay server to aid the connection establishment they will register with a home relay server using their PublicKey.  Other peers which can not establish a direct connection can then establish connection via this relay server.  This will try to assist establishing a direct connection using STUN and holepunching but continue relaying if not possible.
+Peers must know and do verify the PeerID of each other before they can connect. When using a relay server to aid the connection establishment they will register with a home relay server using their PublicKey.  Other peers which can not establish a direct connection can then establish connection via this relay server.  This will try to assist establishing a direct connection using QAD and holepunching but continue relaying if not possible.
 
 Peers can also connect directly without using a relay server. For this, however the listening peer must be directly reachable by the connecting peer via one of it's addresses.
 
diff --git a/iroh/bench/src/bin/bulk.rs b/iroh/bench/src/bin/bulk.rs
@@ -95,7 +95,6 @@ pub fn run_iroh(opt: Opt) -> Result<()> {
         #[cfg(feature = "local-relay")]
         if let Some(relay_server) = relay_server.as_ref() {
             collect_and_print("RelayServerMetrics", &*relay_server.metrics().server);
-            collect_and_print("RelayStunMetrics", &*relay_server.metrics().stun);
         }
     }
 
diff --git a/iroh/docs/local_relay_node.md b/iroh/docs/local_relay_node.md
@@ -16,8 +16,6 @@ To connect to this iroh-relay when doing your normal iroh commands, adjust the i
 # iroh.config.toml:
 [[relay_nodes]]
 url = "http://localhost:3340"
-stun_only = false
-stun_port = 3478
 ```
 
 If you want to give a specific port for the iroh-relay to bind to, you can create a iroh-relay config file and pass that file in using the `--config_path` flag. You need to retain a `secret_key`, so it is recommended to run `iroh-relay --config-path [PATH]` once to generate a secret key and save it to the config file before doing further edits to the file.
@@ -29,13 +27,10 @@ To change the port you want to listen on, change the port in the `addr` field:
 
 secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 addr = "[::]:12345"
-stun_port = 3478
 hostname = "my.relay.network"
-enable_stun = true
 enable_relay = true
 ```
 
 Check [the iroh-relay file's](../src/bin/iroh-relay.rs) `Config` struct for documentation on each configuration field.
 
 If you change the local iroh-relay server's configuration, however, be sure to adjust the associated fields in your iroh config as well.
-
diff --git a/iroh/docs/relay_nodes.md b/iroh/docs/relay_nodes.md
@@ -14,8 +14,6 @@ RelayNode {
   url: format!("https://derp.iroh.network")
          .parse()
          .unwrap(),
-  stun_only: false,
-  stun_port: 3478,
 }
 ```
 
@@ -26,7 +24,5 @@ RelayNode {
   url: format!("https://eu1.derp.iroh.network")
        .parse()
        .unwrap(),
-  stun_only: false,
-  stun_port: 3478,
 }
 ```
diff --git a/iroh/src/defaults.rs b/iroh/src/defaults.rs
@@ -5,10 +5,6 @@
 ///
 /// The port is "QUIC" typed on a phone keypad.
 pub use iroh_relay::defaults::DEFAULT_RELAY_QUIC_PORT;
-/// The default STUN port used by the Relay server.
-///
-/// The STUN port as defined by [RFC
-/// 8489](<https://www.rfc-editor.org/rfc/rfc8489#section-18.6>)
 use url::Url;
 
 /// The default HTTP port used by the Relay server.
diff --git a/iroh/src/endpoint.rs b/iroh/src/endpoint.rs
@@ -1017,7 +1017,7 @@ impl Endpoint {
     /// iroh nodes to establish direct connectivity, depending on the network
     /// situation. The yielded lists of direct addresses contain both the locally-bound
     /// addresses and the [`Endpoint`]'s publicly reachable addresses discovered through
-    /// mechanisms such as [STUN] and port mapping.  Hence usually only a subset of these
+    /// mechanisms such as [QAD] and port mapping.  Hence usually only a subset of these
     /// will be applicable to a certain remote iroh node.
     ///
     /// The [`Endpoint`] continuously monitors the direct addresses for changes as its own
@@ -1045,7 +1045,7 @@ impl Endpoint {
     /// # });
     /// ```
     ///
-    /// [STUN]: https://en.wikipedia.org/wiki/STUN
+    /// [QAD]: https://www.ietf.org/archive/id/draft-seemann-quic-nat-traversal-02.html
     pub fn direct_addresses(&self) -> n0_watcher::Direct<Option<BTreeSet<DirectAddr>>> {
         self.msock.direct_addresses()
     }
diff --git a/iroh/src/lib.rs b/iroh/src/lib.rs
@@ -105,7 +105,7 @@
 //!
 //! Additionally to providing reliable connectivity between iroh nodes, Relay servers
 //! provide some functions to assist in [hole punching].  They have various services to help
-//! nodes understand their own network situation.  This includes offering a [STUN] server,
+//! nodes understand their own network situation.  This includes offering a [QAD] server,
 //! but also a few HTTP extra endpoints as well as responding to ICMP echo requests.
 //!
 //! By default the [number 0] relay servers are used, see [`RelayMode::Default`].
@@ -232,7 +232,7 @@
 //! [bi-directional streams]: crate::endpoint::Connection::open_bi
 //! [hole punching]: https://en.wikipedia.org/wiki/Hole_punching_(networking)
 //! [socket addresses]: https://doc.rust-lang.org/stable/std/net/enum.SocketAddr.html
-//! [STUN]: https://en.wikipedia.org/wiki/STUN
+//! [QAD]: https://www.ietf.org/archive/id/draft-seemann-quic-nat-traversal-02.html
 //! [ALPN]: https://en.wikipedia.org/wiki/Application-Layer_Protocol_Negotiation
 //! [HTTP3]: https://en.wikipedia.org/wiki/HTTP/3
 //! [`SecretKey`]: crate::SecretKey
diff --git a/iroh/src/magicsock.rs b/iroh/src/magicsock.rs
@@ -89,7 +89,7 @@ pub use self::{
     node_map::{ConnectionType, ControlMsg, DirectAddrInfo, RemoteInfo},
 };
 
-/// How long we consider a STUN-derived endpoint valid for. UDP NAT mappings typically
+/// How long we consider a QAD-derived endpoint valid for. UDP NAT mappings typically
 /// expire at 30 seconds, so this is a few seconds shy of that.
 const ENDPOINTS_FRESH_ENOUGH_DURATION: Duration = Duration::from_secs(27);
 
@@ -624,7 +624,7 @@ impl MagicSock {
                 self.metrics.magicsock.recv_gro_datagrams.inc();
             }
 
-            // Chunk through the datagrams in this GRO payload to find disco and stun
+            // Chunk through the datagrams in this GRO payload to find disco
             // packets and forward them to the actor
             for datagram in buf[..quinn_meta.len].chunks_mut(quinn_meta.stride) {
                 if datagram.len() < quinn_meta.stride {
@@ -635,7 +635,7 @@ impl MagicSock {
                     );
                 }
 
-                // Detect DISCO and STUN datagrams and process them.  Overwrite the first
+                // Detect DISCO datagrams and process them.  Overwrite the first
                 // byte of those packets with zero to make Quinn ignore the packet.  This
                 // relies on quinn::EndpointConfig::grease_quic_bit being set to `false`,
                 // which we do in Endpoint::bind.
@@ -728,7 +728,7 @@ impl MagicSock {
                     }
                 }
             } else {
-                // If all datagrams in this buf are DISCO or STUN, set len to zero to make
+                // If all datagrams in this buf are DISCO, set len to zero to make
                 // Quinn skip the buf completely.
                 quinn_meta.len = 0;
             }
@@ -1992,9 +1992,7 @@ impl Actor {
         // Next add STUN addresses from the net_report report.
         if let Some(net_report_report) = net_report_report {
             if let Some(global_v4) = net_report_report.global_v4 {
-                addrs
-                    .entry(global_v4.into())
-                    .or_insert(DirectAddrType::Stun);
+                addrs.entry(global_v4.into()).or_insert(DirectAddrType::Qad);
 
                 // If they're behind a hard NAT and are using a fixed
                 // port locally, assume they might've added a static
@@ -2017,14 +2015,12 @@ impl Actor {
                         addr.set_port(port);
                         addrs
                             .entry(addr.into())
-                            .or_insert(DirectAddrType::Stun4LocalPort);
+                            .or_insert(DirectAddrType::Qad4LocalPort);
                     }
                 }
             }
             if let Some(global_v6) = net_report_report.global_v6 {
-                addrs
-                    .entry(global_v6.into())
-                    .or_insert(DirectAddrType::Stun);
+                addrs.entry(global_v6.into()).or_insert(DirectAddrType::Qad);
             }
         }
 
@@ -2191,7 +2187,7 @@ fn bind_with_fallback(mut addr: SocketAddr) -> io::Result<UdpSocket> {
 ///
 /// These are all the [`DirectAddr`]s that this [`MagicSock`] is aware of for itself.
 /// They include all locally bound ones as well as those discovered by other mechanisms like
-/// STUN.
+/// QAD.
 #[derive(derive_more::Debug, Default, Clone)]
 struct DiscoveredDirectAddrs {
     /// The last set of discovered direct addresses.
@@ -2381,33 +2377,33 @@ pub enum DirectAddrType {
     Unknown,
     /// A locally bound socket address.
     Local,
-    /// Public internet address discovered via STUN.
+    /// Public internet address discovered via QAD.
     ///
-    /// When possible an iroh node will perform STUN to discover which is the address
+    /// When possible an iroh node will perform QAD to discover which is the address
     /// from which it sends data on the public internet.  This can be different from locally
     /// bound addresses when the node is on a local network which performs NAT or similar.
-    Stun,
+    Qad,
     /// An address assigned by the router using port mapping.
     ///
     /// When possible an iroh node will request a port mapping from the local router to
     /// get a publicly routable direct address.
     Portmapped,
-    /// Hard NAT: STUN'ed IPv4 address + local fixed port.
+    /// Hard NAT: QAD'ed IPv4 address + local fixed port.
     ///
     /// It is possible to configure iroh to bound to a specific port and independently
     /// configure the router to forward this port to the iroh node.  This indicates a
-    /// situation like this, which still uses STUN to discover the public address.
-    Stun4LocalPort,
+    /// situation like this, which still uses QAD to discover the public address.
+    Qad4LocalPort,
 }
 
 impl Display for DirectAddrType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             DirectAddrType::Unknown => write!(f, "?"),
             DirectAddrType::Local => write!(f, "local"),
-            DirectAddrType::Stun => write!(f, "stun"),
+            DirectAddrType::Qad => write!(f, "qad"),
             DirectAddrType::Portmapped => write!(f, "portmap"),
-            DirectAddrType::Stun4LocalPort => write!(f, "stun4localport"),
+            DirectAddrType::Qad4LocalPort => write!(f, "qad4localport"),
         }
     }
 }
diff --git a/iroh/src/magicsock/node_map/node_state.rs b/iroh/src/magicsock/node_map/node_state.rs
@@ -43,7 +43,7 @@ const PING_TIMEOUT_DURATION: Duration = Duration::from_secs(5);
 const GOOD_ENOUGH_LATENCY: Duration = Duration::from_millis(5);
 
 /// How long since the last activity we try to keep an established endpoint peering alive.
-/// It's also the idle time at which we stop doing STUN queries to keep NAT mappings alive.
+/// It's also the idle time at which we stop doing QAD queries to keep NAT mappings alive.
 pub(super) const SESSION_ACTIVE_TIMEOUT: Duration = Duration::from_secs(45);
 
 /// How often we try to upgrade to a better patheven if we have some non-relay route that works.
@@ -284,7 +284,9 @@ impl NodeState {
     ) -> (Option<SocketAddr>, Option<RelayUrl>) {
         #[cfg(any(test, feature = "test-utils"))]
         if self.path_selection == PathSelection::RelayOnly {
-            debug!("in `RelayOnly` mode, giving the relay address as the only viable address for this endpoint");
+            debug!(
+                "in `RelayOnly` mode, giving the relay address as the only viable address for this endpoint"
+            );
             return (None, self.relay_url());
         }
         let (best_addr, relay_url) = match self.udp_paths.send_addr(*now, have_ipv6) {
diff --git a/iroh/src/net_report.rs b/iroh/src/net_report.rs
diff --git a/iroh/src/net_report/defaults.rs b/iroh/src/net_report/defaults.rs
diff --git a/iroh/src/net_report/metrics.rs b/iroh/src/net_report/metrics.rs
diff --git a/iroh/src/net_report/probes.rs b/iroh/src/net_report/probes.rs
diff --git a/iroh/src/net_report/reportgen.rs b/iroh/src/net_report/reportgen.rs
diff --git a/iroh/src/test_utils.rs b/iroh/src/test_utils.rs

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,6 @@ pub fn run_iroh(opt: Opt) -> Result<()> {`
`95`	`95`	`#[cfg(feature = "local-relay")]`
`96`	`96`	`if let Some(relay_server) = relay_server.as_ref() {`
`97`	`97`	`collect_and_print("RelayServerMetrics", &*relay_server.metrics().server);`
`98`		`- collect_and_print("RelayStunMetrics", &*relay_server.metrics().stun);`
`99`	`98`	`}`
`100`	`99`	`}`
`101`	`100`