Walk `from` in declaration order; for each key absent from `into`, splice in a clone of the template entry (with its leading comment decor). For keys

Returns true if the path-notify cache slot for `dest` is empty. Used to avoid cloning a full packet on every send when the cache is already populated

Get node info as JSON string (for protocol responses). Automatically adds build info if node_info_privacy is false.

Parse a duration string that accepts either plain seconds ("300") or Go-style duration components ("5m", "1h30m", "2h30m15s").

The peer reader task. Reads frames from the connection and dispatches messages to the router via the shared mutex. Returns Ok(()) for clean shutdown,

Extract the first peer certificate from a TLS connection. Returns `None` for plain TCP or if no peer certificate is available.

The peer writer task. Receives protocol frames and writes them to the connection. Application traffic is drained from `traffic_queue` only when no pr

Get the current number of bytes queued (snapshot).

Read a traffic packet from ironwood, stripping the session type byte.

Read a uvarint from an async reader.

Phase 3 of split recv: update nonce, maybe ratchet, update stats.

Phase 1 of split recv: parse header, determine case, snapshot shared key. Takes &self — no mutation, just reads state.

Delete a flow once it has no backlog left (removing it from the ring).

Remove bloom info for a disconnected peer.

Remove a peer by URI.

Reset the timeout for a destination (called when we receive traffic from them).

Read the remaining bytes.

The router actor: owns the Router exclusively, processes messages from the channel, runs periodic maintenance, and dispatches resulting actions. Repla

Run a control command against the admin socket.

Send GetPeers request to remote node.

Send GetSelf request to remote node.

Send GetTree request to remote node.

Send NodeInfo request to remote node.

Send a message to a specific peer.

Send a batch of traffic packets to their respective peers. Locks the peers mutex once to collect all queue/notify handles, then drops the lock before

Blocking send: wait until the message is enqueued. Used for AddPeer where we must ensure registration completes before spawning the peer reader.

Background reader loop: reads from inner PacketConn, decrypts via sessions, delivers. Background task that periodically cleans up expired sessions and

Set the core reference. Must be called before listen/add_peer.

Set the multicast module reference (called after construction).

Wire up the path_notify callback to deliver to the given ReadWriteCloser. Must be called after both Core and RWC are created.

Check if a rumor lookup should be throttled. Returns false if never sent (new rumor always eligible for first send).

Background reader loop: reads from inner PacketConn, verifies signatures, delivers.

Get the total queued bytes.

Spawn a periodic background task that evicts stale conntrack entries. The task exits automatically once all strong references to `self` are dropped.

Start listeners and connect to configured peers.

Start multicast peer discovery using the current config. If external interfaces have been provided via `update_network_interfaces()`, they will be us

Subscribe to peer connect/disconnect events.

Subtract `b` from `a`, requiring `a.contains(&b)` and `a != b`. Produces `log2(|a|/|b|)` disjoint covering prefixes.

Background task to renew TLS certificate before expiry. Checks every 12 hours and renews if certificate expires within 10 days.

Convert TOML value to JSON value.

Get our current tree coordinates (path from root).

Called by read_from() before waiting on channel. Returns Some(packet) if one is already queued, or None if the reader should wait (recv_ready incremen

Read packets from the TUN device and send them to the network via RWC.

Read packets from the network (RWC) and write them straight into the TUN device.

Remove all active connections whose URI matches `uri`. Called by `remove_peer` to clean up entries that the aborted reconnect task can no longer clean

Update rate counters for all connections (call every ~1 second).

Use a signature response to set a new parent.

Verify a signature from the given public key.

Set a closed-network group password. All nodes that should be able to open sessions with each other must use the same password. An empty password leav

Add a persistent peer to connect to.