// Package mdns provides mDNS (Multicast DNS) advertising and discovery for the scoreboard. package mdns import ( "context" "fmt" "net" "os" "time" "github.com/grandcat/zeroconf" ) // ServiceName is the mDNS service name identifier. const ServiceName = "_sportscore._tcp" // Server advertises the scoreboard via mDNS. type Server struct { server *zeroconf.Server } // NewServer creates a new mDNS server that advertises the scoreboard. func NewServer(instanceName string, port int) (*Server, error) { // Get local network interfaces ifaces, err := net.Interfaces() if err != nil { return nil, fmt.Errorf("failed to get network interfaces: %w", err) } // Filter to only non-loopback interfaces with IPv4 var validIfaces []net.Interface for _, iface := range ifaces { if iface.Flags&net.FlagLoopback != 0 { continue } if iface.Flags&net.FlagUp == 0 { continue } validIfaces = append(validIfaces, iface) } if len(validIfaces) == 0 { return nil, fmt.Errorf("no suitable network interfaces found") } server, err := zeroconf.Register( instanceName, ServiceName, "local.", port, []string{fmt.Sprintf("port=%d", port)}, validIfaces, ) if err != nil { return nil, fmt.Errorf("failed to register mDNS service: %w", err) } fmt.Fprintf(os.Stderr, "[mdns] Registered mDNS service: %s.%s.local. on port %d\n", instanceName, ServiceName, port) return &Server{server: server}, nil } // Stop stops the mDNS server. func (s *Server) Stop() { if s.server != nil { s.server.Shutdown() } } // DiscoveryResult contains information about a discovered scoreboard instance. type DiscoveryResult struct { Instance string Host string Port int Addr string } // Discover scans the network for scoreboard instances. // Returns a list of discovered instances or an error. func Discover() ([]*DiscoveryResult, error) { results := make([]*DiscoveryResult, 0) resolver, err := zeroconf.NewResolver(nil) if err != nil { return nil, fmt.Errorf("failed to create mDNS resolver: %w", err) } entries := make(chan *zeroconf.ServiceEntry) ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) go func() { defer cancel() err := resolver.Browse(ctx, ServiceName, "local.", entries) if err != nil { fmt.Fprintf(os.Stderr, "[mdns] Browse error: %v\n", err) } close(entries) }() for entry := range entries { var addr string if len(entry.AddrIPv4) > 0 { addr = net.JoinHostPort(entry.AddrIPv4[0].String(), fmt.Sprintf("%d", entry.Port)) } else { addr = net.JoinHostPort(entry.HostName, fmt.Sprintf("%d", entry.Port)) } result := &DiscoveryResult{ Instance: entry.Instance, Host: entry.HostName, Port: int(entry.Port), Addr: addr, } results = append(results, result) } return results, nil } // GetServiceName returns the mDNS service name. func GetServiceName() string { return ServiceName }