[msan] Choose in runtime if IPv4 or IPv6 are supported.

[vitalybuka]

Summary

This reverts commit cab5051c691ce27a7ffac41e8e76ceb222ad9549.

[eugenis]

lib/msan/tests/msan_test.cc

952 ↗

(On Diff #94692)

for (int i : {AF_INET, AF_INET6}) {

compiler-rt/trunk/lib/msan/tests/CMakeLists.txt

set(MSAN_UNITTEST_COMMON_CFLAGS
   -fno-exceptions
   -fno-omit-frame-pointer
   -mno-omit-leaf-frame-pointer
   -Wno-deprecated-declarations
   -Wno-unused-variable
   -Wno-zero-length-array
   -Wno-uninitialized
   -Werror=sign-compare
+  -Wno-gnu-zero-variadic-macro-arguments
 )
 set(MSAN_UNITTEST_INSTRUMENTED_CFLAGS
   ${MSAN_UNITTEST_COMMON_CFLAGS}
   -fsanitize=memory
   -fsanitize-memory-track-origins
   -mllvm -msan-keep-going=1
 )
 set(MSAN_UNITTEST_LINK_FLAGS

compiler-rt/trunk/lib/msan/tests/msan_test.cc

public:
   SocketAddr4() { EXPECT_POISONED(sai_); }
   explicit SocketAddr4(uint16_t port) {
     memset(&sai_, 0, sizeof(sai_));
     sai_.sin_family = AF_INET;
     sai_.sin_port = port;
     sai_.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   }
 
-  sockaddr *ptr() override {
-    return reinterpret_cast<sockaddr *>(&sai_);
-  }
+  sockaddr *ptr() override { return reinterpret_cast<sockaddr *>(&sai_); }
 
   size_t size() const override { return sizeof(sai_); }
 
  private:
   sockaddr_in sai_;
 };
 
+class SocketAddr6 : public SocketAddr {
+ public:
+  SocketAddr6() { EXPECT_POISONED(sai_); }
+  explicit SocketAddr6(uint16_t port) {
+    memset(&sai_, 0, sizeof(sai_));
+    sai_.sin6_family = AF_INET6;
+    sai_.sin6_port = port;
+    sai_.sin6_addr = in6addr_loopback;
+  }
+
+  sockaddr *ptr() override { return reinterpret_cast<sockaddr *>(&sai_); }
+
+  size_t size() const override { return sizeof(sai_); }
+
+ private:
+  sockaddr_in6 sai_;
+};
+
+class MemorySanitizerIpTest : public ::testing::TestWithParam<int> {
+ public:
+  void SetUp() override {
+    ASSERT_TRUE(GetParam() == AF_INET || GetParam() == AF_INET6);
+  }
+
   template <class... Args>
-std::unique_ptr<SocketAddr> CreateSockAddr(Args... args) {
+  std::unique_ptr<SocketAddr> CreateSockAddr(Args... args) const {
+    if (GetParam() == AF_INET)
       return std::unique_ptr<SocketAddr>(new SocketAddr4(args...));
+    return std::unique_ptr<SocketAddr>(new SocketAddr6(args...));
+  }
+
+  int CreateSocket(int socket_type) const {
+    return socket(GetParam(), socket_type, 0);
+  }
+};
+
+std::vector<int> GetAvailableIpSocketFamilies() {
+  std::vector<int> result;
+
+  for (int i : std::vector<int>(AF_INET, AF_INET6)) {
+    int s = socket(i, SOCK_STREAM, 0);
+    if (s > 0) {
+      result.push_back(i);
+      close(s);
+    }
+  }
+
+  return result;
 }
 
-int CreateSocket(int socket_type) { return socket(AF_INET, socket_type, 0); }
+INSTANTIATE_TEST_CASE_P(IpTests, MemorySanitizerIpTest,
+                        ::testing::ValuesIn(GetAvailableIpSocketFamilies()));
 
-TEST(MemorySanitizer, accept) {
+TEST_P(MemorySanitizerIpTest, accept) {
   int listen_socket = CreateSocket(SOCK_STREAM);
   ASSERT_LT(0, listen_socket);
 
   auto sai = CreateSockAddr(0);
   int res = bind(listen_socket, sai->ptr(), sai->size());
   ASSERT_EQ(0, res);
 
   res = listen(listen_socket, 1);
TEST_P(MemorySanitizerIpTest, accept) {
   ASSERT_EQ(sai->size(), sz);
   EXPECT_NOT_POISONED2(sai->ptr(), sai->size());
 
   close(new_sock);
   close(connect_socket);
   close(listen_socket);
 }
 
-TEST(MemorySanitizer, recvmsg) {
+TEST_P(MemorySanitizerIpTest, recvmsg) {
   int server_socket = CreateSocket(SOCK_DGRAM);
   ASSERT_LT(0, server_socket);
 
   auto sai = CreateSockAddr(0);
   int res = bind(server_socket, sai->ptr(), sai->size());
   ASSERT_EQ(0, res);
 
   socklen_t sz = sai->size();