An option to use the system multicast interface

- ssdp.SetMulticastSystemAssignedInterface()
- ssdp.GetMulticastSystemAssignedInterface()

Author: koron

internal/multicast/interface.go

@@ -10,6 +10,10 @@ type InterfacesProviderFunc func() []net.Interface
 // If no provider are given, all possible interfaces will be used.
 var InterfacesProvider InterfacesProviderFunc
 
+// SystemAssignedInterface indicates use the system assigned multicast interface or not.
+// InterfacesProvider will be ignored when this is true.
+var SystemAssignedInterface bool = false
+
 // interfaces gets list of net.Interface to multicast UDP packet.
 func interfaces() ([]net.Interface, error) {
 	if p := InterfacesProvider; p != nil {

internal/multicast/multicast.go

@@ -22,6 +22,7 @@ type Conn struct {
 
 type connConfig struct {
 	ttl int
+	sysIf bool
 }
 
 // Listen starts to receiving multicast messages.
@@ -42,16 +43,11 @@ func Listen(r *AddrResolver, opts ...ConnOption) (*Conn, error) {
 		return nil, err
 	}
 	// configure socket to use with multicast.
-	pconn, iflist, err := newIPv4MulticastConn(conn)
+	pconn, ifplist, err := newIPv4MulticastConn(conn, cfg.sysIf)
 	if err != nil {
 		conn.Close()
 		return nil, err
 	}
-	// store interfaces by pointer.
-	ifplist := make([]*net.Interface, 0, len(iflist))
-	for i := range iflist {
-		ifplist = append(ifplist, &iflist[i])
-	}
 	// set TTL
 	if cfg.ttl > 0 {
 		err := pconn.SetTTL(cfg.ttl)
@@ -67,35 +63,58 @@ func Listen(r *AddrResolver, opts ...ConnOption) (*Conn, error) {
 	}, nil
 }
 
-func newIPv4MulticastConn(conn *net.UDPConn) (*ipv4.PacketConn, []net.Interface, error) {
-	iflist, err := interfaces()
-	if err != nil {
-		return nil, nil, err
+// newIPv4MulticastConn create a new multicast connection.
+// 2nd return parameter will be nil when sysIf is true.
+func newIPv4MulticastConn(conn *net.UDPConn, sysIf bool) (*ipv4.PacketConn, []*net.Interface, error) {
+	// sysIf: use system assigned multicast interface.
+	// the empty iflist indicate it.
+	var ifplist []*net.Interface
+	if !sysIf {
+		list, err := interfaces()
+		if err != nil {
+			return nil, nil, err
+		}
+		ifplist = make([]*net.Interface, 0, len(list))
+		for i := range list {
+			ifplist = append(ifplist, &list[i])
+		}
 	}
 	addr, err := SendAddr()
 	if err != nil {
 		return nil, nil, err
 	}
-	pconn, err := joinGroupIPv4(conn, iflist, addr)
+	pconn, err := joinGroupIPv4(conn, ifplist, addr)
 	if err != nil {
 		return nil, nil, err
 	}
-	return pconn, iflist, nil
+	return pconn, ifplist, nil
 }
 
 // joinGroupIPv4 makes the connection join to a group on interfaces.
-func joinGroupIPv4(conn *net.UDPConn, iflist []net.Interface, gaddr net.Addr) (*ipv4.PacketConn, error) {
+// This trys to use system assigned when iflist is nil or empty.
+func joinGroupIPv4(conn *net.UDPConn, ifplist []*net.Interface, gaddr net.Addr) (*ipv4.PacketConn, error) {
 	wrap := ipv4.NewPacketConn(conn)
 	wrap.SetMulticastLoopback(true)
+
+	// try to use the system assigned multicast interface when iflist is empty.
+	if len(ifplist) == 0 {
+		if err := wrap.JoinGroup(nil, gaddr); err != nil {
+			ssdplog.Printf("failed to join group %s on system assigned multicast interface: %s", gaddr.String(), err)
+			return nil, errors.New("no system assigned multicast interfaces had joined to group")
+		}
+		ssdplog.Printf("joined group %s on system assigned multicast interface", gaddr.String())
+		return wrap, nil
+	}
+
 	// add interfaces to multicast group.
 	joined := 0
-	for _, ifi := range iflist {
-		if err := wrap.JoinGroup(&ifi, gaddr); err != nil {
-			ssdplog.Printf("failed to join group %s on %s: %s", gaddr.String(), ifi.Name, err)
+	for _, ifp := range ifplist {
+		if err := wrap.JoinGroup(ifp, gaddr); err != nil {
+			ssdplog.Printf("failed to join group %s on %s: %s", gaddr.String(), ifp.Name, err)
 			continue
 		}
 		joined++
-		ssdplog.Printf("joined group %s on %s (#%d)", gaddr.String(), ifi.Name, ifi.Index)
+		ssdplog.Printf("joined group %s on %s (#%d)", gaddr.String(), ifp.Name, ifp.Index)
 	}
 	if joined == 0 {
 		return nil, errors.New("no interfaces had joined to group")
@@ -117,12 +136,6 @@ type DataProvider interface {
 	Bytes(*net.Interface) []byte
 }
 
-//type multicastDataProviderFunc func(*net.Interface) []byte
-//
-//func (f multicastDataProviderFunc) Bytes(ifi *net.Interface) []byte {
-//	return f(ifi)
-//}
-
 type BytesDataProvider []byte
 
 func (b BytesDataProvider) Bytes(ifi *net.Interface) []byte {
@@ -131,9 +144,11 @@ func (b BytesDataProvider) Bytes(ifi *net.Interface) []byte {
 
 // WriteTo sends a multicast message to interfaces.
 func (mc *Conn) WriteTo(dataProv DataProvider, to net.Addr) (int, error) {
+	// Send a multicast message directory when recipient "to" address is not multicast.
 	if uaddr, ok := to.(*net.UDPAddr); ok && !uaddr.IP.IsMulticast() {
 		return mc.writeToIfi(dataProv, to, nil)
 	}
+	// Send a multicast message to all interfaces (iflist).
 	sum := 0
 	for _, ifp := range mc.ifps {
 		n, err := mc.writeToIfi(dataProv, to, ifp)
@@ -197,3 +212,9 @@ func ConnTTL(ttl int) ConnOption {
 		cfg.ttl = ttl
 	})
 }
+
+func ConnSystemAssginedInterface() ConnOption {
+	return connOptFunc(func(cfg *connConfig) {
+		cfg.sysIf = true
+	})
+}

ssdp.go

@@ -36,18 +36,36 @@ func SetMulticastSendAddrIPv4(addr string) error {
 	return multicast.SetSendAddrIPv4(addr)
 }
 
-var multicastTTL int
-
 func defaultConnOpts() []multicast.ConnOption {
 	var opts []multicast.ConnOption
 	if multicastTTL > 0 {
 		opts = append(opts, multicast.ConnTTL(multicastTTL))
 	}
+	if multicastSystemAssignedInterface {
+		opts = append(opts, multicast.ConnSystemAssginedInterface())
+	}
 	return opts
 }
 
+var multicastTTL int
+
 // SetMulticastTTL sets default TTL of SSDP's UDP packets.
 // 0 default, 1 or greater set TTL.
 func SetMulticastTTL(ttl int) {
 	multicastTTL = ttl
 }
+
+var multicastSystemAssignedInterface bool
+
+// SetMulticastSystemAssignedInterface updates state whether using the system
+// assigned multicast interface or provided interfaces.
+// Default is "false", it uses provided interface (see Interfaces also).
+func SetMulticastSystemAssignedInterface(enable bool) {
+	multicastSystemAssignedInterface = enable
+}
+
+// GetMulticastSystemAssignedInterface returns state using the system assigned
+// multicast interface or provided interfaces.
+func GetMulticastSystemAssignedInterface() bool {
+	return multicastSystemAssignedInterface
+}