Netstack: Allow IP_(ADD|REMOVE)_MEMBERSHIP on AF_INET6 sockets

Just like Linux does.

The new test `AddV4MembershipToV6Socket` passes only if there is a routing
table entry to resolve the ipv4 multicast address, and that is easiest to setup
via a "external networking" test. Now it turns out that the ipv6 "external
networking" test did not really have a second non-loopback (external)
interface, so I've fixed that. Also, the existing "external networking" test
`TestJoinLeaveMulticast` needs only the loopback interface, so I've moved it
to the loopback test.

PiperOrigin-RevId: 807959283

Author: shailend-g

pkg/tcpip/tcpip.go

@@ -49,10 +49,8 @@ import (
 
 // Using the header package here would cause an import cycle.
 const (
-	ipv4AddressSize    = 4
-	ipv4ProtocolNumber = 0x0800
-	ipv6AddressSize    = 16
-	ipv6ProtocolNumber = 0x86dd
+	ipv4AddressSize = 4
+	ipv6AddressSize = 16
 )
 
 const (

pkg/tcpip/tests/integration/BUILD

@@ -128,7 +128,6 @@ go_test(
         "//pkg/tcpip/tests/utils",
         "//pkg/tcpip/testutil",
         "//pkg/tcpip/transport/icmp",
-        "//pkg/tcpip/transport/raw",
         "//pkg/tcpip/transport/udp",
         "//pkg/waiter",
         "@com_github_google_go_cmp//cmp:go_default_library",

pkg/tcpip/tests/integration/multicast_broadcast_test.go

@@ -33,7 +33,6 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/tests/utils"
 	"gvisor.dev/gvisor/pkg/tcpip/testutil"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
-	"gvisor.dev/gvisor/pkg/tcpip/transport/raw"
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 	"gvisor.dev/gvisor/pkg/waiter"
 )
@@ -779,54 +778,3 @@ func TestAddMembershipInterfacePrecedence(t *testing.T) {
 		t.Fatalf("ep.SetSockOpt(&%#v): %s", addOpt, err)
 	}
 }
-
-func TestMismatchedMulticastAddressAndProtocol(t *testing.T) {
-	const nicID = 1
-	// MulticastAddr is IPv4, but proto is IPv6.
-	multicastAddr := tcpip.AddrFromSlice([]byte("\xe0\x01\x02\x03"))
-	s := stack.New(stack.Options{
-		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{icmp.NewProtocol6},
-		RawFactory:         raw.EndpointFactory{},
-	})
-	e := channel.New(0, defaultMTU, "")
-	defer e.Close()
-	if err := s.CreateNIC(nicID, e); err != nil {
-		t.Fatalf("CreateNIC(%d, _): %s", nicID, err)
-	}
-	protoAddr := tcpip.ProtocolAddress{Protocol: header.IPv4ProtocolNumber, AddressWithPrefix: utils.Ipv4Addr}
-	if err := s.AddProtocolAddress(nicID, protoAddr, stack.AddressProperties{}); err != nil {
-		t.Fatalf("AddProtocolAddress(%d, %+v, {}): %s", nicID, protoAddr, err)
-	}
-
-	var wq waiter.Queue
-	ep, err := s.NewRawEndpoint(header.ICMPv6ProtocolNumber, header.IPv6ProtocolNumber, &wq, false)
-	if err != nil {
-		t.Fatalf("NewEndpoint(%d, %d, _): %s", udp.ProtocolNumber, header.IPv6ProtocolNumber, err)
-	}
-	defer ep.Close()
-
-	bindAddr := tcpip.FullAddress{Port: utils.LocalPort}
-	if err := ep.Bind(bindAddr); err != nil {
-		t.Fatalf("ep.Bind(%#v): %s", bindAddr, err)
-	}
-
-	memOpt := tcpip.MembershipOption{
-		MulticastAddr: multicastAddr,
-		NIC:           0,
-		InterfaceAddr: utils.Ipv4Addr.Address,
-	}
-
-	// Add/remove membership should succeed when the interface index is specified,
-	// even if a bad interface address is specified.
-	addOpt := tcpip.AddMembershipOption(memOpt)
-	expErr := &tcpip.ErrInvalidOptionValue{}
-	if err := ep.SetSockOpt(&addOpt); err != expErr {
-		t.Fatalf("ep.SetSockOpt(&%#v): want %q, got %q", addOpt, expErr, err)
-	}
-
-	removeOpt := tcpip.RemoveMembershipOption(memOpt)
-	if err := ep.SetSockOpt(&removeOpt); err != expErr {
-		t.Fatalf("ep.SetSockOpt(&%#v): want %q, got %q", addOpt, expErr, err)
-	}
-}

pkg/tcpip/transport/internal/network/BUILD

@@ -22,6 +22,8 @@ go_library(
         "//pkg/sync",
         "//pkg/tcpip",
         "//pkg/tcpip/header",
+        "//pkg/tcpip/network/ipv4",
+        "//pkg/tcpip/network/ipv6",
         "//pkg/tcpip/stack",
         "//pkg/tcpip/transport",
         "//pkg/waiter",

pkg/tcpip/transport/internal/network/endpoint.go

@@ -24,6 +24,8 @@ import (
 	"gvisor.dev/gvisor/pkg/sync"
 	"gvisor.dev/gvisor/pkg/tcpip"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
+	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
+	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
 	"gvisor.dev/gvisor/pkg/tcpip/transport"
 	"gvisor.dev/gvisor/pkg/waiter"
@@ -952,21 +954,26 @@ func (e *Endpoint) SetSockOpt(opt tcpip.SettableSocketOption) tcpip.Error {
 		e.multicastAddr = addr
 
 	case *tcpip.AddMembershipOption:
-		if !(header.IsV4MulticastAddress(v.MulticastAddr) && e.netProto == header.IPv4ProtocolNumber) && !(header.IsV6MulticastAddress(v.MulticastAddr) && e.netProto == header.IPv6ProtocolNumber) {
+		var proto tcpip.NetworkProtocolNumber
+		switch {
+		case header.IsV4MulticastAddress(v.MulticastAddr):
+			proto = ipv4.ProtocolNumber
+		case header.IsV6MulticastAddress(v.MulticastAddr):
+			proto = ipv6.ProtocolNumber
+		default:
 			return &tcpip.ErrInvalidOptionValue{}
 		}
 
 		nicID := v.NIC
-
 		if v.InterfaceAddr.Unspecified() {
 			if nicID == 0 {
-				if r, err := e.stack.FindRoute(0, tcpip.Address{}, v.MulticastAddr, e.netProto, false /* multicastLoop */); err == nil {
+				if r, err := e.stack.FindRoute(0, tcpip.Address{}, v.MulticastAddr, proto, false /* multicastLoop */); err == nil {
 					nicID = r.NICID()
 					r.Release()
 				}
 			}
 		} else {
-			nicID = e.stack.CheckLocalAddress(nicID, e.netProto, v.InterfaceAddr)
+			nicID = e.stack.CheckLocalAddress(nicID, proto, v.InterfaceAddr)
 		}
 		if nicID == 0 {
 			return &tcpip.ErrUnknownDevice{}
@@ -981,27 +988,33 @@ func (e *Endpoint) SetSockOpt(opt tcpip.SettableSocketOption) tcpip.Error {
 			return &tcpip.ErrPortInUse{}
 		}
 
-		if err := e.stack.JoinGroup(e.netProto, nicID, v.MulticastAddr); err != nil {
+		if err := e.stack.JoinGroup(proto, nicID, v.MulticastAddr); err != nil {
 			return err
 		}
 
 		e.multicastMemberships[memToInsert] = struct{}{}
 
 	case *tcpip.RemoveMembershipOption:
-		if !(header.IsV4MulticastAddress(v.MulticastAddr) && e.netProto == header.IPv4ProtocolNumber) && !(header.IsV6MulticastAddress(v.MulticastAddr) && e.netProto == header.IPv6ProtocolNumber) {
+		var proto tcpip.NetworkProtocolNumber
+		switch {
+		case header.IsV4MulticastAddress(v.MulticastAddr):
+			proto = ipv4.ProtocolNumber
+		case header.IsV6MulticastAddress(v.MulticastAddr):
+			proto = ipv6.ProtocolNumber
+		default:
 			return &tcpip.ErrInvalidOptionValue{}
 		}
 
 		nicID := v.NIC
 		if v.InterfaceAddr.Unspecified() {
 			if nicID == 0 {
-				if r, err := e.stack.FindRoute(0, tcpip.Address{}, v.MulticastAddr, e.netProto, false /* multicastLoop */); err == nil {
+				if r, err := e.stack.FindRoute(0, tcpip.Address{}, v.MulticastAddr, proto, false /* multicastLoop */); err == nil {
 					nicID = r.NICID()
 					r.Release()
 				}
 			}
 		} else {
-			nicID = e.stack.CheckLocalAddress(nicID, e.netProto, v.InterfaceAddr)
+			nicID = e.stack.CheckLocalAddress(nicID, proto, v.InterfaceAddr)
 		}
 		if nicID == 0 {
 			return &tcpip.ErrUnknownDevice{}
@@ -1016,7 +1029,7 @@ func (e *Endpoint) SetSockOpt(opt tcpip.SettableSocketOption) tcpip.Error {
 			return &tcpip.ErrBadLocalAddress{}
 		}
 
-		if err := e.stack.LeaveGroup(e.netProto, nicID, v.MulticastAddr); err != nil {
+		if err := e.stack.LeaveGroup(proto, nicID, v.MulticastAddr); err != nil {
 			return err
 		}
 

test/syscalls/BUILD

@@ -810,6 +810,12 @@ syscall_test(
     test = "//test/syscalls/linux:socket_ipv4_udp_unbound_external_networking_test",
 )
 
+syscall_test(
+    add_hostinet = True,
+    netstack_sr = True,
+    test = "//test/syscalls/linux:socket_ipv6_udp_unbound_external_networking_test",
+)
+
 syscall_test(
     size = "large",
     add_hostinet = True,

test/syscalls/linux/BUILD

@@ -2896,7 +2896,12 @@ cc_library(
         "socket_ipv6_udp_unbound_external_networking.h",
     ],
     deps = select_gtest() + [
+        ":ip_socket_test_util",
         ":socket_ip_udp_unbound_external_networking",
+        "//test/util:posix_error",
+        "//test/util:socket_util",
+        "//test/util:test_util",
+        "@com_google_absl//absl/cleanup",
     ],
     alwayslink = 1,
 )

test/syscalls/linux/socket_ipv6_udp_unbound.cc

@@ -16,6 +16,8 @@
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
+
+#include <cerrno>
 #ifdef __linux__
 #include <linux/in6.h>
 #endif  //  __linux__
@@ -204,5 +206,70 @@ TEST_P(IPv6UDPUnboundSocketTest, SetAndReceiveIPReceiveOrigDstAddr) {
   EXPECT_EQ(received_addr.sin6_port, orig_receiver_addr->sin6_port);
 }
 
+TEST_P(IPv6UDPUnboundSocketTest, TestJoinLeaveMulticast) {
+  auto sender = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
+  auto receiver = ASSERT_NO_ERRNO_AND_VALUE(NewSocket());
+
+  auto receiver_addr = V6Any();
+  ASSERT_THAT(bind(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                   receiver_addr.addr_len),
+              SyscallSucceeds());
+  socklen_t receiver_addr_len = receiver_addr.addr_len;
+  ASSERT_THAT(getsockname(receiver->get(), AsSockAddr(&receiver_addr.addr),
+                          &receiver_addr_len),
+              SyscallSucceeds());
+  EXPECT_EQ(receiver_addr_len, receiver_addr.addr_len);
+
+  // Register to receive multicast packets.
+  auto multicast_addr = V6Multicast();
+  ipv6_mreq group_req = {
+      .ipv6mr_multiaddr =
+          reinterpret_cast<sockaddr_in6*>(&multicast_addr.addr)->sin6_addr,
+      .ipv6mr_interface = static_cast<decltype(ipv6_mreq::ipv6mr_interface)>(
+          ASSERT_NO_ERRNO_AND_VALUE(GetLoopbackIndex())),
+  };
+  ASSERT_THAT(setsockopt(receiver->get(), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
+                         &group_req, sizeof(group_req)),
+              SyscallSucceeds());
+
+  // Set the sender to the loopback interface.
+  auto sender_addr = V6Loopback();
+  ASSERT_THAT(
+      bind(sender->get(), AsSockAddr(&sender_addr.addr), sender_addr.addr_len),
+      SyscallSucceeds());
+
+  // Send a multicast packet.
+  auto send_addr = multicast_addr;
+  reinterpret_cast<sockaddr_in6*>(&send_addr.addr)->sin6_port =
+      reinterpret_cast<sockaddr_in6*>(&receiver_addr.addr)->sin6_port;
+  char send_buf[200];
+  RandomizeBuffer(send_buf, sizeof(send_buf));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
+
+  // Check that we received the multicast packet.
+  char recv_buf[sizeof(send_buf)] = {};
+  ASSERT_THAT(
+      RecvTimeout(receiver->get(), recv_buf, sizeof(recv_buf), 1 /*timeout*/),
+      IsPosixErrorOkAndHolds(sizeof(recv_buf)));
+
+  EXPECT_EQ(0, memcmp(send_buf, recv_buf, sizeof(send_buf)));
+
+  // Leave the group and make sure we don't receive its multicast traffic.
+  ASSERT_THAT(setsockopt(receiver->get(), IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
+                         &group_req, sizeof(group_req)),
+              SyscallSucceeds());
+  RandomizeBuffer(send_buf, sizeof(send_buf));
+  ASSERT_THAT(
+      RetryEINTR(sendto)(sender->get(), send_buf, sizeof(send_buf), 0,
+                         AsSockAddr(&send_addr.addr), send_addr.addr_len),
+      SyscallSucceedsWithValue(sizeof(send_buf)));
+  ASSERT_THAT(RetryEINTR(recv)(receiver->get(), recv_buf, sizeof(recv_buf),
+                               MSG_DONTWAIT),
+              SyscallFailsWithErrno(EAGAIN));
+}
+
 }  // namespace testing
 }  // namespace gvisor