netimps 0.2.1__tar.gz → 0.2.2__tar.gz

{netimps-0.2.1 → netimps-0.2.2}/AGENTS.md

@@ -148,6 +148,23 @@ map:
 - **Check for silent platform gaps before adding a socket option.** `IP_MTU`,
   `IP_MTU_DISCOVER`, `IP_DONTFRAG` and `SO_REUSEPORT` do not exist on Windows;
   binding a multicast socket to the group address fails there too.
+- **IPv6 multicast names an adapter by *index*, IPv4 by *address*.** They are
+  not two spellings of one thing: feeding an address to the v6 side does not
+  raise, it lands as index `0`, which is "kernel's choice". Use
+  `_iface_spec.interface_index()` for anything v6, `interface_address()` for
+  v4.
+- **POSIX delivers asynchronous ICMP errors only to *connected* UDP sockets.**
+  An unconnected probe never sees a port-unreachable and just times out, while
+  Windows reports it either way — so the unconnected version tests green here
+  and under-reports on Linux CI. Also note `_discover_mtu_udp` is still
+  unconnected by design; it treats such errors as failure anyway.
+- **`ThreadPoolExecutor.__exit__` calls `shutdown(wait=True)`,** and its atexit
+  hook joins worker threads too. It is therefore the wrong tool for bounding a
+  blocking call: a daemon `threading.Thread` joined through a queue is what
+  `_dns._resolve_system_once` uses, and why.
+- **Match a ping reply by address token, and remember hostnames are plural.**
+  `gethostbyname` is IPv4-only — use `getaddrinfo` with an explicit family, or
+  `ipv6=` silently does nothing.
 - **Windows exposes no cached path MTU.** Already investigated, so do not
   re-derive it: `MIB_IPFORWARDROW.dwForwardMtu` reads 0 (unsupported), and
   `MIB_IPFORWARD_ROW2` has no MTU field. `Interface.mtu` is the link MTU;

{netimps-0.2.1 → netimps-0.2.2}/CHANGELOG.md

@@ -7,6 +7,49 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-08-16
+
+### Fixed
+
+- **`resolve_system(timeout=)` now bounds wall time.** The lookup ran inside a
+  `with ThreadPoolExecutor(...)` block, whose `__exit__` joins the worker
+  still blocked in `getaddrinfo` -- so the timeout changed *what* was raised
+  but not *when*, and a 30s resolver hang still cost the caller 30s despite
+  `timeout=5.0`. `resolve()`'s chain consequently never reached `nslookup` at
+  the promised deadline either.
+- **`interface=` is honoured for IPv6 multicast.** The spec was reduced to an
+  address and then passed to `if_nametoindex()`, which always fails for an
+  address string, so the `IPV6_JOIN_GROUP` index silently stayed `0` --
+  "kernel's choice", the exact default `interface=` exists to override.
+  `IPV6_MULTICAST_IF` was never set at all, so sends left by the default
+  route while joins listened elsewhere. Both now resolve the adapter to its
+  interface index. IPv4 behaviour is unchanged.
+- **`ping(hostname, ipv6=True)` is no longer always false.** The reply address
+  was resolved with the IPv4-only `gethostbyname`, so a v6 reply was checked
+  against a v4 expectation and never matched. The expectation now comes from
+  `getaddrinfo` honouring `ipv6=`, and a name resolving to several addresses
+  counts as answered if the reply came from any of them.
+- **`ping(..., method="tcp"/"udp")` reaches IPv6 destinations.** Both probes
+  opened `AF_INET` sockets unconditionally, so a v6 destination failed inside
+  `connect`/`sendto` and was reported as unreachable -- a wrong falsy answer
+  rather than an error. `ipv6=` now applies to all three methods.
+- **`ping(..., method="udp")` detects ICMP port-unreachable on POSIX.** The
+  probe socket was never connected, and POSIX delivers asynchronous ICMP
+  errors only to connected UDP sockets -- so the documented "host answered,
+  nothing listening" signal worked on Windows alone and the probe just timed
+  out on Linux/macOS. `ECONNREFUSED` and `ECONNRESET` both now count.
+
+### Documentation
+
+- The shipped API header named `PingResult.source` and `Route.source`; both
+  attributes are spelled `.src` (and `PingResult.host` was unlisted).
+- Recorded the per-family multicast interface selection, `ping`'s `ipv6=`
+  reach across all three methods, and `resolve_system`'s real wall-time
+  deadline in the shipped header.
+- Added the known, still-unverified macOS/BSD `ping6` reply-shape gap
+  (`from <addr>,` rather than `from <addr>:`) to the header rather than
+  guessing a parser change without a macOS runner.
+
 ## [0.2.1] - 2026-07-30
 
 ### Added
@@ -196,7 +239,10 @@ below is simply what the package contains.
 - **`Host`**, **`retry()`/`backoff_delays()`**, and the named networks `APIPA`,
   `LOOPBACK_V4`, `LOOPBACK_V6`, `LINK_LOCAL_V6`.
 
-[Unreleased]: https://github.com/jose-pr/netimps/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/jose-pr/netimps/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/jose-pr/netimps/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/jose-pr/netimps/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/jose-pr/netimps/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/jose-pr/netimps/compare/v0.0.2...v0.1.0
 [0.0.2]: https://github.com/jose-pr/netimps/releases/tag/v0.0.2
 [0.0.1]: https://github.com/jose-pr/netimps/releases/tag/v0.0.1

{netimps-0.2.1 → netimps-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: netimps
-Version: 0.2.1
+Version: 0.2.2
 Summary: Small, self-contained network utilities: IP/MAC types, DNS lookup, ping, NIC discovery
 Project-URL: Homepage, https://github.com/jose-pr/netimps
 Project-URL: Documentation, https://jose-pr.github.io/netimps/
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Networking
 Classifier: Typing :: Typed
 Requires-Python: >=3.9

{netimps-0.2.1 → netimps-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "netimps"
-version = "0.2.1"
+version = "0.2.2"
 authors = [{ name = "Jose A." }]
 description = "Small, self-contained network utilities: IP/MAC types, DNS lookup, ping, NIC discovery"
 readme = "README.md"
@@ -19,6 +19,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: OS Independent",
     "Topic :: System :: Networking",
     "Typing :: Typed",

{netimps-0.2.1 → netimps-0.2.2}/src/netimps/AGENTS.md

@@ -16,7 +16,7 @@ is self-contained: it references nothing outside the installed distribution.
 testing, releasing) is not shipped; it lives with the source at
 <https://github.com/jose-pr/netimps>.
 
-`netimps.__version__` — the package version string (currently `"0.2.1"`).
+`netimps.__version__` — the package version string (currently `"0.2.2"`).
 
 ## Argument naming
 
@@ -309,6 +309,12 @@ cannot see (its own DNS query bypasses all of that). Same `AddressLike`
   trick `host`/`getent` scripts use. A **list of domain names** tries `query`
   qualified with each, in order, one `getaddrinfo` call per candidate,
   independent of (and untouched by) the OS's own search list.
+- **`timeout` bounds wall time, per candidate name tried.** `getaddrinfo` has
+  no timeout of its own, so each attempt runs in a daemon helper thread that
+  is abandoned at the deadline; the underlying call is not cancelled, but
+  neither the caller nor interpreter exit waits for it. A broken resolver
+  therefore costs `timeout`, not however long it takes to give up — which is
+  also what lets `resolve()`'s chain reach `nslookup` on schedule.
 
 **`resolve_nslookup(query, rdtype=None, ns=None, timeout=5.0, search=True)`**
 
@@ -338,8 +344,8 @@ path is usable. Address records only: `rdtype` must be `"a"`, `"aaaa"` or
 **`ping(dst, tries=1, timeout=1.0, ipv6=None, src=None, size=None, ttl=None, dont_fragment=False, method="icmp", port=None) -> PingResult`**
 
 `PingResult` is **truthy on success** and compares equal to `bool`, so
-`if ping(host):` and `== True` keep working, while carrying `.ok`, `.rtt_ms`,
-`.ttl`, `.source`, `.attempts`.
+`if ping(host):` and `== True` keep working, while carrying `.ok`, `.host`,
+`.rtt_ms`, `.ttl`, `.src`, `.attempts`.
 
 | Argument | Notes |
 | --- | --- |
@@ -360,6 +366,19 @@ failure. `tcp` and `udp` also report `rtt_ms`; only ICMP reports `ttl`.
   "TTL expired in transit", so the reply address is verified rather than
   trusting the exit code. Locale-independent — it matches on addresses, never
   prose.
+- **`ipv6=` applies to all three methods**, not just the ICMP binary: it picks
+  the `-6`/`-4` flag, the family the reply address is resolved in, and the
+  family the `tcp`/`udp` probe sockets use. `ipv6=None` accepts either. A
+  hostname with several addresses counts as answered if the reply came from
+  any of them.
+- **The `udp` probe connects its socket before sending**, which is why the ICMP
+  port-unreachable is seen on POSIX and not only on Windows — an unconnected
+  UDP socket is never delivered an asynchronous ICMP error on Linux/BSD.
+  `ECONNREFUSED` and `ECONNRESET` both count as "the host answered".
+- **Known gap: macOS/BSD `ping6` reply lines.** Verification looks for
+  `from <addr>:`; BSD `ping6` is documented as printing `from <addr>,`. If
+  that holds, a v6 *literal* ping on macOS verifies as falsy despite a healthy
+  reply. Unverified on real hardware, so deliberately not "fixed" by guess.
 - An unusable `src` (unknown MAC, adapter with no address, foreign address)
   gives a falsy result — it **never silently falls back** to the default route.
 - Never raises: missing binary, hung subprocess and non-zero exit are all falsy.
@@ -417,7 +436,7 @@ failure. `tcp` and `udp` also report `rtt_ms`; only ICMP reports `ttl`.
 
 ## Routing, hops and MTU
 
-- **`get_route(dst="8.8.8.8") -> Route`** — `.source`, `.gateway`,
+- **`get_route(dst="8.8.8.8") -> Route`** — `.dst`, `.src`, `.gateway`,
   `.interface_index`, `.on_link`. **First hop only, deliberately** — that is
   available unprivileged everywhere, unlike the full path. Never raises;
   unknown pieces are `None`/`0`. The gateway resolves on Windows and Linux only.
@@ -501,6 +520,12 @@ receives nothing, and looks fine:
   *both* send and receive. Without it the kernel picks by routing table, which
   on a multi-homed host is regularly the wrong adapter. An unknown interface
   **raises** rather than falling back.
+- **The two families identify an adapter differently**, and the spec is
+  resolved accordingly: IPv4 by local *address* (`IP_ADD_MEMBERSHIP`,
+  `IP_MULTICAST_IF`), IPv6 by interface *index* (`IPV6_JOIN_GROUP`,
+  `IPV6_MULTICAST_IF`). An adapter the platform reports **no index** for
+  raises for an IPv6 group, because index `0` means "kernel's choice" — the
+  default `interface=` was passed to override.
 
 ## UDP with arrival interface
 

{netimps-0.2.1 → netimps-0.2.2}/src/netimps/__init__.py

@@ -163,7 +163,7 @@ __all__ = [
     "HOST_DN",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 #: Fully-qualified (or short) name of the host running this process.
 HOST_DN = _platform.node()

{netimps-0.2.1 → netimps-0.2.2}/src/netimps/_dns.py

@@ -246,18 +246,36 @@ def _resolve_system_once(
         except _socket.gaierror:
             return []
     else:
-        import concurrent.futures as _futures
-
-        with _futures.ThreadPoolExecutor(max_workers=1) as pool:
-            future = pool.submit(_lookup)
+        import queue as _queue
+        import threading as _threading
+
+        # A *daemon* thread, joined through a queue rather than a
+        # ThreadPoolExecutor. The executor looks like the obvious fit and is
+        # the wrong one: `__exit__` calls `shutdown(wait=True)` on every
+        # supported Python, so raising out of the `with` block joins the
+        # worker still stuck inside getaddrinfo() and the caller waits out the
+        # whole hang anyway -- `timeout` would change *what* is raised but not
+        # *when*. Its atexit hook joins pool threads too, so even
+        # `shutdown(wait=False)` would move the hang to interpreter exit.
+        # A daemon thread is abandoned at both points, which is the contract.
+        outcome: "_queue.Queue" = _queue.Queue(maxsize=1)
+
+        def _run_lookup() -> None:
             try:
-                infos = future.result(timeout=timeout)
-            except _socket.gaierror:
+                outcome.put(("ok", _lookup()))
+            except BaseException as exc:  # relayed to the caller verbatim
+                outcome.put(("error", exc))
+
+        _threading.Thread(target=_run_lookup, daemon=True).start()
+        try:
+            kind, payload = outcome.get(timeout=timeout)
+        except _queue.Empty:
+            raise ResolutionError("resolve_system timed out after %.1fs" % (timeout,))
+        if kind == "error":
+            if isinstance(payload, _socket.gaierror):
                 return []
-            except _futures.TimeoutError as exc:
-                raise ResolutionError(
-                    "resolve_system timed out after %.1fs" % (timeout,)
-                ) from exc
+            raise payload
+        infos = payload
 
     seen = []
     for info in infos:
@@ -308,9 +326,13 @@ def resolve_system(
         otherwise. Anything else raises.
     :param timeout: seconds to wait *per candidate name tried* (see
         ``search``). There is no native per-call timeout for
-        ``getaddrinfo``/``gethostbyaddr``, so each attempt runs in a helper
-        thread and is abandoned (without cancelling the underlying blocking
-        call) past the deadline. ``None`` waits indefinitely.
+        ``getaddrinfo``/``gethostbyaddr``, so each attempt runs in a daemon
+        helper thread and is abandoned (without cancelling the underlying
+        blocking call) past the deadline. The deadline bounds **wall time**:
+        a resolver that hangs for a minute still raises
+        :class:`ResolutionError` at ``timeout``, and the abandoned thread
+        holds up neither the caller nor interpreter exit. ``None`` waits
+        indefinitely.
     :param search: how to expand an unqualified ``query``. Ignored for
         ``rdtype="ptr"`` -- an address has no search-list suffix to try.
         There is no per-call search-list override on

{netimps-0.2.1 → netimps-0.2.2}/src/netimps/_iface_spec.py

@@ -24,7 +24,7 @@ from ._ifaddrs import Interface
 from ._ip import IPAddress
 from ._mac import MACAddress
 
-__all__ = ["interface_address"]
+__all__ = ["interface_address", "interface_index"]
 
 #: The loose "which interface?" spec every ``src=``/``interface=`` parameter
 #: in the package accepts: an :class:`Interface`, a :class:`MACAddress` (or
@@ -109,3 +109,71 @@ def interface_address(
     if parsed is None:
         return _fail("cannot resolve %r to a local address" % (interface,))
     return parsed
+
+
+def interface_index(interface: "InterfaceSpec", strict: bool = True) -> "Optional[int]":
+    """Reduce an interface spec to its OS interface index.
+
+    The index-shaped sibling of :func:`interface_address`, for the OS
+    interfaces that identify an adapter by number rather than by address:
+    ``IPV6_JOIN_GROUP``/``IPV6_LEAVE_GROUP``'s ``mreq`` and
+    ``IPV6_MULTICAST_IF`` all take an index. Reducing such a spec to an
+    address first is not a lossy shortcut but an outright wrong answer --
+    ``if_nametoindex("2001:db8::5")`` raises, leaving index ``0``, which the
+    kernel reads as "choose by routing table".
+
+    :param interface: an :class:`Interface`, a :class:`MACAddress` (or MAC
+        string), an adapter name, an address held by a local interface, or
+        ``None``.
+    :param strict: when True (the default) a spec that names no local
+        interface -- or one the platform reports no index for -- raises
+        :class:`ValueError`; when False it returns ``None``.
+
+    ``None`` in gives ``None`` out -- "no preference", which callers translate
+    into leaving the index at ``0`` and letting the kernel pick.
+
+    An index of ``0`` is never returned as a value: ``0`` *is* the kernel's
+    "pick for me", so reporting it for an adapter the caller explicitly named
+    would recreate the silent wrong-adapter failure this exists to prevent.
+    """
+    from . import IPAddress, MACAddress, interface_for, is_valid, try_parse
+    from ._ifaddrs import Interface, get_interfaces
+
+    if interface is None:
+        return None
+
+    def _fail(message: str):
+        if strict:
+            raise ValueError(message)
+        return None
+
+    match: "Optional[Interface]" = None
+    if isinstance(interface, Interface):
+        match = interface
+    elif isinstance(interface, MACAddress) or (
+        isinstance(interface, str) and is_valid(interface, MACAddress)
+    ):
+        wanted = MACAddress(interface)
+        match = interface_for(wanted)
+        if match is None:
+            return _fail("no interface with MAC %s" % (wanted,))
+    elif isinstance(interface, str) and not is_valid(interface, IPAddress):
+        # An adapter name. Resolved through get_interfaces() rather than
+        # socket.if_nametoindex() so the Windows *friendly* name works too --
+        # if_nametoindex there wants the adapter's GUID-ish system name.
+        match = next(
+            (iface for iface in get_interfaces() if iface.name == interface), None
+        )
+        if match is None:
+            return _fail("no interface named %r" % (interface,))
+    else:
+        address = try_parse(str(interface).strip(), IPAddress)
+        if address is None:
+            return _fail("cannot resolve %r to a local interface" % (interface,))
+        match = interface_for(address)
+        if match is None:
+            return _fail("no local interface holds address %s" % (address,))
+
+    if not match.index:
+        return _fail("interface %r reports no index on this platform" % (match.name,))
+    return match.index

{netimps-0.2.1 → netimps-0.2.2}/src/netimps/_multicast.py

@@ -15,6 +15,13 @@ The parts people get wrong
   routing table -- which on a host with VMs, containers or a VPN is regularly
   the wrong adapter, and the socket then receives nothing at all. Pass one when
   it matters.
+* **The two families name an adapter differently.** IPv4 identifies it by a
+  local *address* (``IP_ADD_MEMBERSHIP``'s ``imr_interface``,
+  ``IP_MULTICAST_IF``); IPv6 identifies it by interface *index*
+  (``IPV6_JOIN_GROUP``'s ``ipv6mr_interface``, ``IPV6_MULTICAST_IF``).
+  Feeding an address to the v6 side does not fail loudly -- it lands as index
+  ``0``, which means "kernel's choice", i.e. the default this module exists
+  to let you override.
 * **``SO_REUSEPORT`` does not exist on Windows.** Code that sets it
   unconditionally raises there, so it is applied only where present.
 * **Default TTL is 1**, confining traffic to the local link. Raising it is a
@@ -25,9 +32,10 @@ from __future__ import annotations
 
 import socket as _socket
 import struct as _struct
-from typing import List, Optional, Union
+from typing import List, Union
 
 from ._iface_spec import InterfaceSpec, interface_address as _interface_address
+from ._iface_spec import interface_index as _interface_index
 from ._ip import AddressLike
 
 __all__ = ["multicast_socket", "join_group", "leave_group", "is_multicast"]
@@ -50,18 +58,19 @@ def is_multicast(address: "AddressLike") -> bool:
     return bool(parsed is not None and parsed.is_multicast)
 
 
-def _membership_request(group: str, interface_address: "Optional[str]", ipv6: bool):
-    """Build the mreq structure for IP_ADD_MEMBERSHIP / IPV6_JOIN_GROUP."""
+def _membership_request(group: str, interface: "InterfaceSpec", ipv6: bool):
+    """Build the mreq structure for IP_ADD_MEMBERSHIP / IPV6_JOIN_GROUP.
+
+    Resolving the interface spec lives here rather than in the callers
+    because the two families need *different* resolutions of the same spec:
+    IPv4 wants a local address, IPv6 wants an interface index.
+    """
     if ipv6:
-        index = 0
-        if interface_address:
-            try:
-                index = _socket.if_nametoindex(interface_address)
-            except (OSError, AttributeError, ValueError):
-                index = 0
+        index = _interface_index(interface) or 0
         return _socket.inet_pton(_socket.AF_INET6, group) + _struct.pack("@I", index)
 
-    local = interface_address or "0.0.0.0"
+    address = _interface_address(interface, want_ipv6=False)
+    local = "0.0.0.0" if address is None else str(address)
     return _struct.pack("4s4s", _socket.inet_aton(group), _socket.inet_aton(local))
 
 
@@ -75,17 +84,19 @@ def join_group(
     host with VMs or a VPN is often the wrong adapter -- and the failure is
     silent: the socket simply never receives.
 
-    Raises :class:`ValueError` for a non-multicast group or an interface with no
-    usable address, and :class:`OSError` if the kernel rejects the join.
+    The spec is resolved per family: to a local **address** for an IPv4
+    group, to an interface **index** for an IPv6 one, since that is what each
+    ``mreq`` carries.
+
+    Raises :class:`ValueError` for a non-multicast group, or for an interface
+    that resolves to no usable address (IPv4) or no index (IPv6), and
+    :class:`OSError` if the kernel rejects the join.
     """
     if not is_multicast(group):
         raise ValueError("%r is not a multicast group" % (group,))
 
     ipv6 = ":" in group
-    address = _interface_address(interface, want_ipv6=ipv6)
-    request = _membership_request(
-        group, None if address is None else str(address), ipv6
-    )
+    request = _membership_request(group, interface, ipv6)
     if ipv6:
         sock.setsockopt(_socket.IPPROTO_IPV6, _socket.IPV6_JOIN_GROUP, request)
     else:
@@ -104,10 +115,7 @@ def leave_group(
         raise ValueError("%r is not a multicast group" % (group,))
 
     ipv6 = ":" in group
-    address = _interface_address(interface, want_ipv6=ipv6)
-    request = _membership_request(
-        group, None if address is None else str(address), ipv6
-    )
+    request = _membership_request(group, interface, ipv6)
     if ipv6:
         sock.setsockopt(_socket.IPPROTO_IPV6, _socket.IPV6_LEAVE_GROUP, request)
     else:
@@ -139,7 +147,10 @@ def multicast_socket(
         pass the port the senders use.
     :param interface: :class:`Interface`, MAC, adapter name or local address to
         join through. **Strongly recommended on multi-homed hosts** -- the
-        routing-table default is frequently the wrong adapter.
+        routing-table default is frequently the wrong adapter. Pins outgoing
+        traffic as well as the joins (``IP_MULTICAST_IF`` for IPv4,
+        ``IPV6_MULTICAST_IF`` for IPv6), so sends and receives cannot end up
+        on different adapters.
     :param ttl: hop limit for outgoing datagrams. The default of **1 keeps
         traffic on the local link**; raise it deliberately to cross routers.
     :param loop: whether this host receives its own transmissions. ``True``
@@ -180,14 +191,26 @@ def multicast_socket(
             sock.setsockopt(_socket.IPPROTO_IP, _socket.IP_MULTICAST_LOOP, int(loop))
 
         # Pin outgoing traffic to the chosen adapter as well as incoming, or
-        # sends leave by the default route while joins listen elsewhere.
-        outgoing = _interface_address(interface, want_ipv6=ipv6)
-        if outgoing is not None and not ipv6:
-            sock.setsockopt(
-                _socket.IPPROTO_IP,
-                _socket.IP_MULTICAST_IF,
-                _socket.inet_aton(str(outgoing)),
-            )
+        # sends leave by the default route while joins listen elsewhere. The
+        # option is per-family: IPv4 names the adapter by local address, IPv6
+        # by interface index.
+        if interface is not None:
+            if ipv6:
+                index = _interface_index(interface)
+                if index:
+                    sock.setsockopt(
+                        _socket.IPPROTO_IPV6,
+                        _socket.IPV6_MULTICAST_IF,
+                        _struct.pack("@I", index),
+                    )
+            else:
+                outgoing = _interface_address(interface, want_ipv6=False)
+                if outgoing is not None:
+                    sock.setsockopt(
+                        _socket.IPPROTO_IP,
+                        _socket.IP_MULTICAST_IF,
+                        _socket.inet_aton(str(outgoing)),
+                    )
 
         if bind:
             # "" rather than the group address: binding to the group works on