Discover peers over mDNS and link them (R76 slice 3)

.config/nextest.toml

@@ -24,6 +24,10 @@ docker = { max-threads = 4 }
 # so the group exists only to keep the plain-cargo path calm and stays
 # serialized out of caution rather than need.
 keyring = { max-threads = 1 }
+# Every mDNS discovery proof binds the loopback multicast group and drives a
+# real daemon. Concurrent proofs contend for the loopback, and that stalls a
+# link renewal past its bound, so the proofs serialize.
+discovery = { max-threads = 1 }
 
 [[profile.default.overrides]]
 filter = 'test(secret_stores::) | test(teardown::) | test(e2e::) | test(revocation::)'
@@ -60,3 +64,13 @@ filter = 'package(connetto-file-server) & (test(serve::) | test(sweep::) | test(
 test-group = 'docker'
 threads-required = 2
 slow-timeout = { period = "120s", terminate-after = 5 }
+
+[[profile.default.overrides]]
+filter = '''
+test(two_nodes_discover_each_other_and_autolink)
+| test(a_renewal_re_registers_under_a_new_fingerprint)
+| test(a_stopped_discovery_serves_again)
+| test(two_clients_discover_each_other_and_autolink)
+| test(clients_without_autolink_report_and_link_only_on_the_call)
+'''
+test-group = 'discovery'

.github/workflows/ci.yml

@@ -681,6 +681,10 @@ jobs:
   rust-tests:
     name: Rust tests ${{ matrix.name }}
     runs-on: ubuntu-latest
+    # The discovery proofs fail here, never skip, when loopback multicast is
+    # missing (R76 slice 3).
+    env:
+      CONNETTO_REQUIRE_MULTICAST: "1"
     timeout-minutes: 60
     strategy:
       fail-fast: false

.github/workflows/coverage.yml

@@ -25,6 +25,10 @@ jobs:
   coverage:
     name: Coverage ${{ matrix.name }}
     runs-on: ubuntu-latest
+    # The discovery proofs fail here, never skip, when loopback multicast is
+    # missing (R76 slice 3).
+    env:
+      CONNETTO_REQUIRE_MULTICAST: "1"
     timeout-minutes: 90
     # Neither a fork's pull request nor a Dependabot run can read
     # CODECOV_TOKEN, so the upload runs for same-repo branches and main only.

crates/connetto-client/Cargo.toml

@@ -166,8 +166,9 @@ ring = { version = "0.17", features = ["std"], optional = true }
 # The binary derives the schema version it declares from the translated
 # bundle, the same step the server runs. Native only, with the binary.
 connetto-schema = { workspace = true, optional = true }
-# The peer link the device serves and dials (R76).
-connetto-peer = { path = "../connetto-peer", optional = true }
+# The peer link the device serves and dials (R76). Its discovery feature is
+# on, so a peer build always browses and autolinks what it finds (R76 slice 3).
+connetto-peer = { path = "../connetto-peer", optional = true, features = ["discovery"] }
 # The page codec, one per target, both selected here rather than by a feature
 # because `ReplicaCipher::Encrypted` cannot be honest without it: in a SQLite
 # with no codec, `PRAGMA key` is an unrecognised pragma that succeeds silently
@@ -333,6 +334,9 @@ rcgen = "0.13"
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
 tokio-rustls = { version = "0.26", default-features = false, features = ["tls12"] }
 tokio = { version = "1", features = ["test-util"] }
+# The loopback multicast probe the discovery proofs run before they trust the
+# interface, shared with the peer crate's own proofs.
+connetto-peer = { path = "../connetto-peer", features = ["discovery", "test-support"] }
 
 # The fake Secret Service the Linux store tests serve on a peer-to-peer bus.
 [target.'cfg(target_os = "linux")'.dev-dependencies]

crates/connetto-client/src/builder/native.rs

@@ -450,6 +450,8 @@ struct DeviceSetup {
     refused: Option<String>,
     roots: Vec<Vec<u8>>,
     #[cfg(feature = "peer")]
+    peer_autolink: bool,
+    #[cfg(feature = "peer")]
     peer_listen: SocketAddr,
     #[cfg(feature = "peer")]
     peer_accepted: Vec<AttestationLevel>,
@@ -467,6 +469,8 @@ impl Default for DeviceSetup {
             refused: None,
             roots: Vec::new(),
             #[cfg(feature = "peer")]
+            peer_autolink: true,
+            #[cfg(feature = "peer")]
             peer_listen: SocketAddr::from(([0, 0, 0, 0], 0)),
             #[cfg(feature = "peer")]
             peer_accepted: AttestationLevel::ALL.to_vec(),
@@ -578,6 +582,15 @@ where
         self
     }
 
+    /// Whether this device dials the peers discovery finds, on by default
+    /// (R76 decision 12).
+    #[cfg(feature = "peer")]
+    #[must_use]
+    pub fn with_peer_autolink(mut self, autolink: bool) -> Self {
+        self.device.peer_autolink = autolink;
+        self
+    }
+
     /// The attestation levels this device accepts from its peers, all three
     /// by default (R76 decision 8).
     #[cfg(feature = "peer")]
@@ -725,22 +738,32 @@ where
                 #[cfg(feature = "peer")]
                 let (peer_events, peer_events_rx) = mpsc::unbounded_channel();
                 #[cfg(feature = "peer")]
+                let node = connetto_peer::Node::new(
+                    connetto_peer::Trust {
+                        roots: device.roots.clone(),
+                        accepted: device.peer_accepted,
+                    },
+                    Arc::new(connetto_peer::SystemClock),
+                    peer_events,
+                )
+                .map_err(|connetto_peer::TrustError::Root { index, .. }| {
+                    ClientError::InvalidDeploymentRoot { index }
+                })?;
+                #[cfg(feature = "peer")]
+                let (discovery_events, discovery_events_rx) = mpsc::unbounded_channel();
+                #[cfg(feature = "peer")]
                 let peer = Peer {
-                    node: connetto_peer::Node::new(
-                        connetto_peer::Trust {
-                            roots: device.roots.clone(),
-                            accepted: device.peer_accepted,
-                        },
-                        Arc::new(connetto_peer::SystemClock),
-                        peer_events,
-                    )
-                    .map_err(
-                        |connetto_peer::TrustError::Root { index, .. }| {
-                            ClientError::InvalidDeploymentRoot { index }
-                        },
-                    )?,
+                    node: node.clone(),
+                    discovery: connetto_peer::Discovery::new(
+                        node,
+                        device.peer_autolink,
+                        discovery_events,
+                    ),
                     listen: device.peer_listen,
                     events: peer_events_rx,
+                    discovery_events: discovery_events_rx,
+                    #[cfg(all(feature = "peer", target_os = "android"))]
+                    java: device.java.clone(),
                 };
                 let (enroller, handle) = Enroller::new(
                     keys,