v0.4.25: Agent-side mDNS interface filtering, preferred IP TXT, --config flag, installer interface picker

Author: DAB-LABS

CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to SMART Sniffer are documented here.
 
+## v0.4.25 — 2026-03-20
+
+### Added
+- **Agent: mDNS interface filtering** — auto-skips Docker, ZeroTier, Tailscale, WireGuard, and other virtual interfaces by default; only advertises on real LAN interfaces
+- **Agent: `advertise_interface` config option** — restrict mDNS to a specific interface (e.g., `advertise_interface: eth0`)
+- **Agent: `ip=` mDNS TXT record** — agent reports its preferred LAN IP so the HA integration doesn't have to guess
+- **Agent: `--config` flag** — specify a custom config file path (`smartha-agent --config /path/to/config.yaml`)
+- **Agent: `--interface` flag** — CLI override for mDNS interface (`smartha-agent --interface eth0`)
+- **Installer: interface picker** — during install, presents detected interfaces with labels (Docker, ZeroTier, etc.) and lets the user choose which to advertise on
+- **Integration: reads agent `ip=` TXT field** — trusts the agent's preferred IP over local scoring when available; falls back gracefully for older agents
+
+### Fixed
+- Duplicate mDNS discoveries from Docker bridges, VPNs, and mDNS reflectors surfacing the same agent at multiple IPs
+- IPv6 addresses deprioritized in IP scoring (unreliable across VLANs in home networks)
+
 ## v0.4.24 — 2026-03-20
 
 ### Fixed

agent/config.go

@@ -3,7 +3,9 @@ package main
 import (
 	"flag"
 	"fmt"
+	"net"
 	"os"
+	"strings"
 	"time"
 
 	"gopkg.in/yaml.v3"
@@ -12,10 +14,11 @@ import (
 // Config holds all agent configuration. Values are resolved with this
 // precedence: CLI flags > config file > defaults.
 type Config struct {
-	Port         int           `yaml:"port"`
-	Token        string        `yaml:"token"`
-	ScanInterval time.Duration `yaml:"scan_interval"`
-	MDNS         *bool         `yaml:"mdns"` // pointer so we can detect "not set" vs "set to false"
+	Port               int           `yaml:"port"`
+	Token              string        `yaml:"token"`
+	ScanInterval       time.Duration `yaml:"scan_interval"`
+	MDNS               *bool         `yaml:"mdns"`                // pointer so we can detect "not set" vs "set to false"
+	AdvertiseInterface string        `yaml:"advertise_interface"` // restrict mDNS to this interface (e.g. "eth0")
 }
 
 // defaultConfig returns sane defaults.
@@ -26,31 +29,61 @@ func defaultConfig() Config {
 	}
 }
 
+// defaultSkipPrefixes are interface name prefixes that are skipped when no
+// explicit advertise_interface is configured. These are almost never the
+// real LAN interface and cause duplicate/unreachable mDNS discoveries.
+var defaultSkipPrefixes = []string{
+	"docker", // Docker bridge (docker0)
+	"br-",    // Docker custom networks
+	"veth",   // Docker/container veth pairs
+	"zt",     // ZeroTier VPN
+	"tailscale", "ts", // Tailscale VPN
+	"wg",    // WireGuard VPN
+	"virbr", // libvirt/KVM virtual bridge
+	"vbox",  // VirtualBox host-only
+	"vmnet", // VMware host-only
+	"lo",    // Loopback
+}
+
 // LoadConfig reads configuration from config.yaml (if present) then overlays
 // CLI flags. CLI flags always win.
 func LoadConfig() (*Config, error) {
 	cfg := defaultConfig()
 
+	// --- Parse the --config flag first (before other flags) ---
+	configPath := flag.String("config", "", "Path to config.yaml (default: auto-detect)")
+	port := flag.Int("port", 0, "HTTP listen port (default 9099)")
+	token := flag.String("token", "", "Bearer token for API auth (optional)")
+	interval := flag.Duration("scan-interval", 0, "Drive rescan interval (e.g. 30s, 2m)")
+	noMDNS := flag.Bool("no-mdns", false, "Disable mDNS/Zeroconf service advertisement")
+	advIface := flag.String("interface", "", "Restrict mDNS advertisement to this network interface")
+	flag.Parse()
+
 	// --- Attempt to load config.yaml ---
-	// We look in the working directory first, then next to the binary.
-	for _, path := range []string{"config.yaml", "/etc/smartha-agent/config.yaml"} {
-		data, err := os.ReadFile(path)
+	if *configPath != "" {
+		// Explicit path — must exist.
+		data, err := os.ReadFile(*configPath)
 		if err != nil {
-			continue // file not found — that's fine
+			return nil, fmt.Errorf("reading config file %s: %w", *configPath, err)
 		}
 		if err := yaml.Unmarshal(data, &cfg); err != nil {
-			return nil, fmt.Errorf("parsing %s: %w", path, err)
+			return nil, fmt.Errorf("parsing %s: %w", *configPath, err)
+		}
+	} else {
+		// Auto-detect: working directory first, then system path.
+		for _, path := range []string{"config.yaml", "/etc/smartha-agent/config.yaml"} {
+			data, err := os.ReadFile(path)
+			if err != nil {
+				continue // file not found — that's fine
+			}
+			if err := yaml.Unmarshal(data, &cfg); err != nil {
+				return nil, fmt.Errorf("parsing %s: %w", path, err)
+			}
+			break
 		}
-		break
 	}
 
 	// --- CLI flags (override file values) ---
-	port := flag.Int("port", 0, "HTTP listen port (default 9099)")
-	token := flag.String("token", "", "Bearer token for API auth (optional)")
-	interval := flag.Duration("scan-interval", 0, "Drive rescan interval (e.g. 30s, 2m)")
-	noMDNS := flag.Bool("no-mdns", false, "Disable mDNS/Zeroconf service advertisement")
-	flag.Parse()
-
 	if *port != 0 {
 		cfg.Port = *port
 	}
@@ -64,6 +97,9 @@ func LoadConfig() (*Config, error) {
 		f := false
 		cfg.MDNS = &f
 	}
+	if *advIface != "" {
+		cfg.AdvertiseInterface = *advIface
+	}
 
 	// Sanity checks
 	if cfg.Port < 1 || cfg.Port > 65535 {
@@ -83,3 +119,143 @@ func (c *Config) MDNSEnabled() bool {
 	}
 	return *c.MDNS
 }
+
+// ResolveAdvertiseInterfaces returns the list of net.Interface to pass to
+// zeroconf.Register(). If advertise_interface is set, it returns just that
+// interface. Otherwise, it filters out known virtual/VPN interfaces.
+func (c *Config) ResolveAdvertiseInterfaces() ([]net.Interface, string) {
+	// Explicit interface configured — use only that one.
+	if c.AdvertiseInterface != "" {
+		iface, err := net.InterfaceByName(c.AdvertiseInterface)
+		if err != nil {
+			return nil, fmt.Sprintf("WARNING: interface %q not found, advertising on all", c.AdvertiseInterface)
+		}
+		return []net.Interface{*iface}, fmt.Sprintf("interface %s", c.AdvertiseInterface)
+	}
+
+	// No explicit interface — auto-filter known virtual interfaces.
+	allIfaces, err := net.Interfaces()
+	if err != nil {
+		return nil, "all interfaces (could not enumerate)"
+	}
+
+	var filtered []net.Interface
+	var skipped []string
+	for _, iface := range allIfaces {
+		// Skip interfaces that are down.
+		if iface.Flags&net.FlagUp == 0 {
+			continue
+		}
+		// Skip loopback.
+		if iface.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+		// Skip known virtual/VPN prefixes.
+		nameLower := strings.ToLower(iface.Name)
+		skip := false
+		for _, prefix := range defaultSkipPrefixes {
+			if strings.HasPrefix(nameLower, prefix) {
+				skip = true
+				skipped = append(skipped, iface.Name)
+				break
+			}
+		}
+		if !skip {
+			filtered = append(filtered, iface)
+		}
+	}
+
+	if len(filtered) == 0 {
+		// All interfaces were filtered — fall back to all.
+		return nil, "all interfaces (auto-filter found none)"
+	}
+
+	desc := interfaceNames(filtered)
+	if len(skipped) > 0 {
+		desc += " (skipped: " + strings.Join(skipped, ", ") + ")"
+	}
+	return filtered, desc
+}
+
+// PreferredIP returns the best IP address from the given interfaces for
+// inclusion in the mDNS TXT record. Prefers 192.168.x / 10.x over other
+// ranges. Returns empty string if no suitable IP is found.
+func PreferredIP(ifaces []net.Interface) string {
+	// If no interface filter, enumerate all.
+	if len(ifaces) == 0 {
+		var err error
+		ifaces, err = net.Interfaces()
+		if err != nil {
+			return ""
+		}
+	}
+
+	type candidate struct {
+		ip    string
+		score int
+	}
+	var candidates []candidate
+
+	for _, iface := range ifaces {
+		// Skip known virtual interfaces.
+		nameLower := strings.ToLower(iface.Name)
+		isVirtual := false
+		for _, prefix := range defaultSkipPrefixes {
+			if strings.HasPrefix(nameLower, prefix) {
+				isVirtual = true
+				break
+			}
+		}
+
+		addrs, err := iface.Addrs()
+		if err != nil {
+			continue
+		}
+		for _, addr := range addrs {
+			var ip net.IP
+			switch v := addr.(type) {
+			case *net.IPNet:
+				ip = v.IP
+			case *net.IPAddr:
+				ip = v.IP
+			}
+			if ip == nil || ip.IsLoopback() || ip.To4() == nil {
+				continue // skip IPv6 and loopback
+			}
+			ipStr := ip.String()
+			score := 80
+			if isVirtual {
+				score = 90
+			} else if strings.HasPrefix(ipStr, "192.168.") || strings.HasPrefix(ipStr, "10.") {
+				score = 10
+			} else if strings.HasPrefix(ipStr, "172.") {
+				score = 50
+			} else if strings.HasPrefix(ipStr, "100.") {
+				score = 70
+			}
+			candidates = append(candidates, candidate{ipStr, score})
+		}
+	}
+
+	if len(candidates) == 0 {
+		return ""
+	}
+
+	// Find the best (lowest score).
+	best := candidates[0]
+	for _, c := range candidates[1:] {
+		if c.score < best.score {
+			best = c
+		}
+	}
+	return best.ip
+}
+
+// interfaceNames returns a comma-separated list of interface names.
+func interfaceNames(ifaces []net.Interface) string {
+	names := make([]string, len(ifaces))
+	for i, iface := range ifaces {
+		names[i] = iface.Name
+	}
+	return strings.Join(names, ", ")
+}

agent/config.yaml.example

@@ -18,3 +18,15 @@ scan_interval: 60s
 # Home Assistant can auto-discover it.
 # Set to false to disable (or use --no-mdns flag).
 mdns: true
+
+# Restrict mDNS advertisement to a specific network interface.
+# When set, the agent only advertises on this interface and reports
+# its IP in the mDNS TXT record so Home Assistant connects to the
+# correct address.
+#
+# When not set (default), the agent auto-filters known virtual
+# interfaces (Docker, ZeroTier, Tailscale, WireGuard, etc.) and
+# advertises on all remaining physical interfaces.
+#
+# Examples: eth0, enp1s0, en0, bond0
+# advertise_interface: eth0

agent/main.go

@@ -67,6 +67,9 @@ func main() {
 	mdnsLabel := "disabled"
 	if cfg.MDNSEnabled() {
 		mdnsLabel = "enabled"
+		if cfg.AdvertiseInterface != "" {
+			mdnsLabel += " (interface: " + cfg.AdvertiseInterface + ")"
+		}
 	}
 	log.Printf("SMART Sniffer Agent v%s", version)
 	log.Printf("smartctl version: %s", smartctlVer)
@@ -119,6 +122,15 @@ func main() {
 		if cfg.Token != "" {
 			authFlag = "1"
 		}
+
+		// Resolve which interfaces to advertise on.
+		ifaces, ifaceDesc := cfg.ResolveAdvertiseInterfaces()
+		log.Printf("mDNS: interfaces: %s", ifaceDesc)
+
+		// Determine preferred IP for TXT record so the HA integration
+		// doesn't have to guess which IP is the real LAN address.
+		preferredIP := PreferredIP(ifaces)
+
 		txt := []string{
 			"txtvers=1",
 			"version=" + version,
@@ -127,8 +139,13 @@ func main() {
 			"auth=" + authFlag,
 			"drives=" + strconv.Itoa(len(drives)),
 		}
+		if preferredIP != "" {
+			txt = append(txt, "ip="+preferredIP)
+			log.Printf("mDNS: preferred IP: %s", preferredIP)
+		}
+
 		instance := "smartha-" + hostname
-		mdnsServer, err = zeroconf.Register(instance, "_smartha._tcp", "local.", cfg.Port, txt, nil)
+		mdnsServer, err = zeroconf.Register(instance, "_smartha._tcp", "local.", cfg.Port, txt, ifaces)
 		if err != nil {
 			log.Printf("WARNING: mDNS registration failed: %v", err)
 		} else {

custom_components/smart_sniffer/config_flow.py

@@ -174,10 +174,20 @@ async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:
         """Handle discovery via mDNS/Zeroconf."""
-        host = self._pick_best_ip(discovery_info)
         port = discovery_info.port
         properties = discovery_info.properties
-        hostname = properties.get("hostname", host)
+        hostname = properties.get("hostname", "")
+
+        # Agent v0.4.25+ includes an "ip" TXT field with its preferred LAN
+        # address. Trust it over our own scoring when present.
+        agent_preferred_ip = properties.get("ip", "")
+        if agent_preferred_ip:
+            host = agent_preferred_ip
+        else:
+            host = self._pick_best_ip(discovery_info)
+
+        if not hostname:
+            hostname = host
 
         # Migrate any existing IP-based unique IDs to hostname-based.
         self._migrate_legacy_unique_ids(hostname, host, port)

custom_components/smart_sniffer/manifest.json

@@ -9,6 +9,6 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/DAB-LABS/smart-sniffer/issues",
   "requirements": [],
-  "version": "0.4.24",
+  "version": "0.4.25",
   "zeroconf": [{"type": "_smartha._tcp.local."}]
 }