python-zeroconf
diff --git a/‎src/zeroconf/_core.py‎
Lines changed: 1 addition & 1 deletion b/‎src/zeroconf/_core.py‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/zeroconf/_utils/net.py‎
Lines changed: 40 additions & 9 deletions b/‎src/zeroconf/_utils/net.py‎
Lines changed: 40 additions & 9 deletions
diff --git a/‎tests/test_core.py‎
Lines changed: 0 additions & 1 deletion b/‎tests/test_core.py‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎tests/utils/test_net.py‎
Lines changed: 52 additions & 0 deletions b/‎tests/utils/test_net.py‎
Lines changed: 52 additions & 0 deletions
@@ -195,7 +195,7 @@ def __init__(
             receive queries arriving on them.
         """
         if ip_version is None:
-            ip_version = autodetect_ip_version(interfaces)
+            ip_version = autodetect_ip_version(interfaces, multicast_addresses)
 
         self.done = False
 
 
@@ -458,15 +458,34 @@ def create_sockets(
     if multicast_addresses and unicast:
         raise ValueError("multicast_addresses is incompatible with unicast=True")
 
+    # Reject IP-version-incompatible entries up front so callers get a clear
+    # error instead of a confusing adapter-lookup or socket-syscall failure.
+    if multicast_addresses:
+        if ip_version == IPVersion.V4Only:
+            for entry in multicast_addresses:
+                if isinstance(entry, (int, tuple)) or (
+                    isinstance(entry, str) and ipaddress.ip_address(entry).version == 6
+                ):
+                    raise ValueError("multicast_addresses contains IPv6 entries but ip_version is V4Only")
+        elif ip_version == IPVersion.V6Only:
+            for entry in multicast_addresses:
+                if isinstance(entry, str) and ipaddress.ip_address(entry).version == 4:
+                    raise ValueError("multicast_addresses contains IPv4 entries but ip_version is V6Only")
+
     if unicast:
         listen_socket = None
     else:
         listen_socket = new_socket(bind_addr=("",), ip_version=ip_version, apple_p2p=apple_p2p)
 
     normalized_interfaces = normalize_interface_choice(interfaces, ip_version)
-    extra_multicast_members = (
-        normalize_interface_choice(list(multicast_addresses), ip_version) if multicast_addresses else []
-    )
+    if multicast_addresses:
+        extra_multicast_members = normalize_interface_choice(list(multicast_addresses), ip_version)
+        # Strip entries already covered by ``interfaces`` so add_multicast_member
+        # is not called twice for the same membership.
+        interface_set = set(normalized_interfaces)
+        extra_multicast_members = [m for m in extra_multicast_members if m not in interface_set]
+    else:
+        extra_multicast_members = []
 
     # If we are using InterfaceChoice.Default with only IPv4 or only IPv6, we can use
     # a single socket to listen and respond.
@@ -510,17 +529,29 @@ def can_send_to(ipv6_socket: bool, address: str) -> bool:
     return ":" in address if ipv6_socket else ":" not in address
 
 
-def autodetect_ip_version(interfaces: InterfacesType) -> IPVersion:
+def autodetect_ip_version(
+    interfaces: InterfacesType,
+    multicast_addresses: Sequence[str | int | tuple[tuple[str, int, int], int]] | None = None,
+) -> IPVersion:
     """Auto detect the IP version when it is not provided."""
+    has_v6 = False
+    has_v4 = False
     if isinstance(interfaces, list):
         has_v6 = any(
             isinstance(i, int) or (isinstance(i, str) and ipaddress.ip_address(i).version == 6)
             for i in interfaces
         )
         has_v4 = any(isinstance(i, str) and ipaddress.ip_address(i).version == 4 for i in interfaces)
-        if has_v4 and has_v6:
-            return IPVersion.All
-        if has_v6:
-            return IPVersion.V6Only
-
+    if multicast_addresses:
+        has_v6 = has_v6 or any(
+            isinstance(i, (int, tuple)) or (isinstance(i, str) and ipaddress.ip_address(i).version == 6)
+            for i in multicast_addresses
+        )
+        has_v4 = has_v4 or any(
+            isinstance(i, str) and ipaddress.ip_address(i).version == 4 for i in multicast_addresses
+        )
+    if has_v4 and has_v6:
+        return IPVersion.All
+    if has_v6:
+        return IPVersion.V6Only
     return IPVersion.V4Only
@@ -190,7 +190,6 @@ def test_multicast_addresses_forwarded_to_create_sockets(self):
             zc = r.Zeroconf(
                 interfaces=["127.0.0.1"],
                 multicast_addresses=["192.168.1.5"],
-                unicast=True,
             )
             try:
                 _, kwargs = mock_create.call_args
 
@@ -524,3 +524,55 @@ def test_create_sockets_multicast_addresses_default_path() -> None:
     joined = [c.args[1] for c in mock_add.call_args_list if c.args[0] is listen_mock]
     assert "0.0.0.0" in joined
     assert "192.168.1.5" in joined
+
+
+def test_create_sockets_multicast_addresses_v4_rejects_v6_entry() -> None:
+    """V4Only listen socket rejects IPv6 multicast_addresses entries."""
+    with pytest.raises(ValueError, match="IPv6"):
+        r.create_sockets(
+            interfaces=["127.0.0.1"],
+            multicast_addresses=["2001:db8::"],
+            ip_version=r.IPVersion.V4Only,
+        )
+
+
+def test_create_sockets_multicast_addresses_v6_rejects_v4_entry() -> None:
+    """V6Only listen socket rejects IPv4 multicast_addresses entries."""
+    with pytest.raises(ValueError, match="IPv4"):
+        r.create_sockets(
+            interfaces=[1],
+            multicast_addresses=["192.168.1.5"],
+            ip_version=r.IPVersion.V6Only,
+        )
+
+
+def test_create_sockets_multicast_addresses_deduped_against_interfaces() -> None:
+    """Addresses present in both interfaces and multicast_addresses join only once."""
+    listen_mock = Mock(spec=socket.socket)
+    respond_mock = Mock(spec=socket.socket)
+
+    def _new_socket(bind_addr, **kwargs):
+        return listen_mock if bind_addr == ("",) else respond_mock
+
+    with (
+        patch("zeroconf._utils.net.new_socket", side_effect=_new_socket),
+        patch("zeroconf._utils.net.add_multicast_member", return_value=True) as mock_add,
+        patch("zeroconf._utils.net.set_respond_socket_multicast_options"),
+        patch("zeroconf._utils.net.socket.socket.setsockopt"),
+    ):
+        r.create_sockets(
+            interfaces=["127.0.0.1"],
+            multicast_addresses=["127.0.0.1", "192.168.1.5"],
+            ip_version=r.IPVersion.V4Only,
+        )
+
+    joined_127 = [c for c in mock_add.call_args_list if c.args[0] is listen_mock and c.args[1] == "127.0.0.1"]
+    assert len(joined_127) == 1
+
+
+def test_autodetect_ip_version_includes_multicast_addresses() -> None:
+    """autodetect_ip_version sees IPv6 entries from multicast_addresses."""
+    assert (
+        netutils.autodetect_ip_version(["127.0.0.1"], multicast_addresses=["2001:db8::"]) is r.IPVersion.All
+    )
+    assert netutils.autodetect_ip_version([], multicast_addresses=["2001:db8::"]) is r.IPVersion.V6Only
Original file line number	Diff line number	Diff line change
@@ -190,7 +190,6 @@ def test_multicast_addresses_forwarded_to_create_sockets(self):
190	190	zc = r.Zeroconf(
191	191	interfaces=["127.0.0.1"],
192	192	multicast_addresses=["192.168.1.5"],
193		- unicast=True,
194	193	)
195	194	try:
196	195	_, kwargs = mock_create.call_args