git: 5bae837f316c - main - capsicum-test: make the code WARNS=6 clean

From: Enji Cooper <ngie_at_FreeBSD.org>
Date: Tue, 10 Nov 2026 01:32:59 UTC
The branch main has been updated by ngie:

URL: https://cgit.FreeBSD.org/src/commit/?id=5bae837f316ca96b69c61bae15bd61da76e7f3ea

commit 5bae837f316ca96b69c61bae15bd61da76e7f3ea
Author:     Enji Cooper <ngie@FreeBSD.org>
AuthorDate: 2026-11-10 01:29:25 +0000
Commit:     Enji Cooper <ngie@FreeBSD.org>
CommitDate: 2026-11-10 01:29:25 +0000

    capsicum-test: make the code WARNS=6 clean
    
    Make the code WARNS=6 clean by doing the following:
    - Renaming variables (-Wshadow).
    - Use memcpy instead of assigning the result of CMSG_DATA to a variable
      (-Wcast-align).
    - Wrap some macros with do-while(0) to avoid variable collisions
      (-Wshadow).
    - Push one of the TRACE statements up by 1 layer to avoid a collision
      between 2 calls of TRACE via the same overarching macro.
    
    This was needed in order for the code to build properly with D61066,
    since the code was not compiling with WARNS set to 3 at the testcase
    level.
    
    MFC after: 1 week
    
    Reviewed by:    markj
    Differential Revision:  https://reviews.freebsd.org/D61080
---
 tests/sys/capsicum/Makefile         |  2 --
 tests/sys/capsicum/capability-fd.cc | 10 ++++---
 tests/sys/capsicum/capmode.cc       |  2 +-
 tests/sys/capsicum/capsicum-test.h  | 36 ++++++++++++++++-------
 tests/sys/capsicum/fexecve.cc       | 12 ++++----
 tests/sys/capsicum/procdesc.cc      |  6 ++--
 tests/sys/capsicum/sctp.cc          | 24 +++++++--------
 tests/sys/capsicum/socket.cc        | 58 ++++++++++++++++++-------------------
 8 files changed, 84 insertions(+), 66 deletions(-)

diff --git a/tests/sys/capsicum/Makefile b/tests/sys/capsicum/Makefile
index 788fa9f9394c..9a88c9cf0ec1 100644
--- a/tests/sys/capsicum/Makefile
+++ b/tests/sys/capsicum/Makefile
@@ -56,8 +56,6 @@ BINDIR=	${TESTSDIR}
 BINMODE.mini-me.noexec=	${NOBINMODE}
 BINMODE.mini-me.setuid=	4555
 
-WARNS.capsicum-test=	3
-
 .endif # MK_GOOGLETEST
 
 .include <bsd.test.mk>
diff --git a/tests/sys/capsicum/capability-fd.cc b/tests/sys/capsicum/capability-fd.cc
index a9e4d30ac4b9..5a153d827e2c 100644
--- a/tests/sys/capsicum/capability-fd.cc
+++ b/tests/sys/capsicum/capability-fd.cc
@@ -974,6 +974,8 @@ FORK_TEST_ON(Capability, SocketTransfer, TmpFile("cap_fd_transfer")) {
 
   pid_t child = fork();
   if (child == 0) {
+    int cap_fd2;
+
     // Child: enter cap mode
     EXPECT_OK(cap_enter());
     // Child: send startup notification
@@ -984,16 +986,16 @@ FORK_TEST_ON(Capability, SocketTransfer, TmpFile("cap_fd_transfer")) {
     EXPECT_OK(rc);
     EXPECT_LE(CMSG_LEN(sizeof(int)), mh.msg_controllen);
     cmptr = CMSG_FIRSTHDR(&mh);
-    int cap_fd = *(int*)CMSG_DATA(cmptr);
+    memcpy(&cap_fd2, CMSG_DATA(cmptr), sizeof(cap_fd2));
     EXPECT_EQ(CMSG_LEN(sizeof(int)), cmptr->cmsg_len);
     cmptr = CMSG_NXTHDR(&mh, cmptr);
     EXPECT_TRUE(cmptr == NULL);
 
     // Child: confirm we can do the right operations on the capability
     cap_rights_t rights;
-    EXPECT_OK(cap_rights_get(cap_fd, &rights));
+    EXPECT_OK(cap_rights_get(cap_fd2, &rights));
     EXPECT_RIGHTS_EQ(&r_rs, &rights);
-    TryReadWrite(cap_fd);
+    TryReadWrite(cap_fd2);
 
     // Child: acknowledge that we have received and tested the file descriptor
     SEND_INT_MESSAGE(sock_fds[0], MSG_CHILD_FD_RECEIVED);
@@ -1024,7 +1026,7 @@ FORK_TEST_ON(Capability, SocketTransfer, TmpFile("cap_fd_transfer")) {
   cmptr->cmsg_level = SOL_SOCKET;
   cmptr->cmsg_type = SCM_RIGHTS;
   cmptr->cmsg_len = CMSG_LEN(sizeof(int));
-  *(int *)CMSG_DATA(cmptr) = cap_fd;
+  memcpy(CMSG_DATA(cmptr), &cap_fd, sizeof(cap_fd));
   buffer1[0] = 0;
   iov[0].iov_len = 1;
   int rc = sendmsg(sock_fds[1], &mh, 0);
diff --git a/tests/sys/capsicum/capmode.cc b/tests/sys/capsicum/capmode.cc
index fdc572f11b5b..4cf6f24420e3 100644
--- a/tests/sys/capsicum/capmode.cc
+++ b/tests/sys/capsicum/capmode.cc
@@ -158,7 +158,7 @@ FORK_TEST_F(WithFiles, AllowedSocketSyscalls) {
   if (rc < 0) {
     EXPECT_EQ(EAGAIN, errno);
   }
-  char ch;
+  char ch = 'a';
   EXPECT_OK(write(fd_file_, &ch, sizeof(ch)));
 
   // These calls will fail for lack of e.g. a proper name to send to,
diff --git a/tests/sys/capsicum/capsicum-test.h b/tests/sys/capsicum/capsicum-test.h
index 7433814b31c8..5503a7ef260f 100644
--- a/tests/sys/capsicum/capsicum-test.h
+++ b/tests/sys/capsicum/capsicum-test.h
@@ -67,7 +67,7 @@ const char *TmpFile(const char *pathname);
 // Implemented as a macro to allow access to the test case instance's
 // HasFailure() method, which is reported as the forked process's
 // exit status.
-#define _RUN_FORKED(INNERCODE, TESTCASENAME, TESTNAME)         \
+#define _RUN_FORKED(INNERCODE, TESTCASENAME, TESTNAME) do {    \
     pid_t pid = force_nofork ? 0 : fork();                     \
     if (pid == 0) {                                            \
       INNERCODE;                                               \
@@ -95,10 +95,13 @@ const char *TmpFile(const char *pathname);
                         strerror(errno), errno);               \
         ADD_FAILURE() << "Failed to wait for child";           \
       } else {                                                 \
-        int rc = WIFEXITED(status) ? WEXITSTATUS(status) : -1; \
-        EXPECT_EQ(0, rc);                                      \
+        int exit_status =                                      \
+          WIFEXITED(status) ? WEXITSTATUS(status) : -1;        \
+        EXPECT_EQ(0, exit_status);                             \
       }                                                        \
-    }
+    }                                                          \
+} while (0)
+
 #define _RUN_FORKED_MEM(THIS, TESTFN, TESTCASENAME, TESTNAME)  \
   _RUN_FORKED(MaybeRunWithThread(THIS, &TESTFN), TESTCASENAME, TESTNAME);
 #define _RUN_FORKED_FN(TESTFN, TESTCASENAME, TESTNAME)   \
@@ -137,15 +140,28 @@ const char *TmpFile(const char *pathname);
 // Emit errno information on failure
 #define EXPECT_OK(v) EXPECT_LE(0, v) << "   errno " << errno << " " << strerror(errno)
 
-// Expect a syscall to fail with the given error.
-#define EXPECT_SYSCALL_FAIL(E, C) \
+// Expect a syscall to fail with the given error (inner).
+//
+// This is required because unfortunately googletest "computes" trace variables
+// using line numbers instead of another unique ID and 2 calls to
+// `SCOPED_TRACE(..)` via the same macro results in `-Wshadow`-related compiler
+// errors: https://github.com/google/googletest/issues/5143
+#define EXPECT_SYSCALL_FAIL_NO_TRACE(E, C) \
     do { \
-      SCOPED_TRACE(#C); \
       EXPECT_GT(0, C); \
       EXPECT_EQ(E, errno) << "expected '" << strerror(E) \
                           << "' but got '" << strerror(errno) << "'"; \
     } while (0)
 
+// Expect a syscall to fail with the given error (with tracing).
+//
+// See the comment above (for `EXPECT_SYSCALL_FAIL_NO_TRACE`).
+#define EXPECT_SYSCALL_FAIL(E, C) \
+    do { \
+      SCOPED_TRACE(#C); \
+      EXPECT_SYSCALL_FAIL_NO_TRACE((E), (C)); \
+    } while (0)
+
 // Expect a syscall to fail with anything other than the given error.
 #define EXPECT_SYSCALL_FAIL_NOT(E, C) \
     do { \
@@ -169,9 +185,9 @@ const char *TmpFile(const char *pathname);
       SCOPED_TRACE(GTEST_STRINGIFY_(openat((fd), (path), (flags)))); \
       const int result = openat((fd), (path), (flags)); \
       if (((flags) & O_BENEATH) == O_BENEATH) { \
-        EXPECT_SYSCALL_FAIL(E_NO_TRAVERSE_O_BENEATH, result); \
+        EXPECT_SYSCALL_FAIL_NO_TRACE(E_NO_TRAVERSE_O_BENEATH, result); \
       } else { \
-        EXPECT_SYSCALL_FAIL(E_NO_TRAVERSE_CAPABILITY, result); \
+        EXPECT_SYSCALL_FAIL_NO_TRACE(E_NO_TRAVERSE_CAPABILITY, result); \
       } \
       if (result >= 0) { close(result); } \
     } while (0)
@@ -180,7 +196,7 @@ const char *TmpFile(const char *pathname);
     do { \
       SCOPED_TRACE(GTEST_STRINGIFY_(openat((fd), (path), (flags)))); \
       const int result = openat((fd), (path), (flags)); \
-      EXPECT_SYSCALL_FAIL(E_NO_TRAVERSE_CAPABILITY, result); \
+      EXPECT_SYSCALL_FAIL_NO_TRACE(E_NO_TRAVERSE_CAPABILITY, result); \
       if (result >= 0) { close(result); } \
     } while (0)
 #endif
diff --git a/tests/sys/capsicum/fexecve.cc b/tests/sys/capsicum/fexecve.cc
index 86df2af06388..6ff5a657c35a 100644
--- a/tests/sys/capsicum/fexecve.cc
+++ b/tests/sys/capsicum/fexecve.cc
@@ -32,9 +32,9 @@ class Execve : public ::testing::Test {
     if (exec_fd_ < 0) {
       fprintf(stderr, "Error! Failed to open %s\n", exec_prog_.c_str());
     }
-    argv_checkroot_[0] = (char*)exec_prog_.c_str();
-    argv_fail_[0] = (char*)exec_prog_.c_str();
-    argv_pass_[0] = (char*)exec_prog_.c_str();
+    argv_checkroot_[0] = __DECONST(char*, exec_prog_.c_str());
+    argv_fail_[0] = __DECONST(char*, exec_prog_.c_str());
+    argv_pass_[0] = __DECONST(char*, exec_prog_.c_str());
   }
   ~Execve() {
     if (exec_fd_ >= 0) {
@@ -43,9 +43,9 @@ class Execve : public ::testing::Test {
     }
   }
 protected:
-  char* argv_checkroot_[3] = {nullptr, (char*)"--checkroot", nullptr};
-  char* argv_fail_[3] = {nullptr, (char*)"--fail", nullptr};
-  char* argv_pass_[3] = {nullptr, (char*)"--pass", nullptr};
+  char* argv_checkroot_[3] = {nullptr, __DECONST(char*, "--checkroot"), nullptr};
+  char* argv_fail_[3] = {nullptr, __DECONST(char*, "--fail"), nullptr};
+  char* argv_pass_[3] = {nullptr, __DECONST(char*, "--pass"), nullptr};
   std::string exec_prog_, exec_prog_noexec_, exec_prog_setuid_;
   int exec_fd_;
 };
diff --git a/tests/sys/capsicum/procdesc.cc b/tests/sys/capsicum/procdesc.cc
index f25324e4efc7..c92edaf4b695 100644
--- a/tests/sys/capsicum/procdesc.cc
+++ b/tests/sys/capsicum/procdesc.cc
@@ -983,6 +983,8 @@ TEST_F(PipePdfork, PassProcessDescriptor) {
   if (verbose) fprintf(stderr, "[%d] about to fork()\n", getpid_());
   pid_t child2 = fork();
   if (child2 == 0) {
+    int pd;
+
     // Child: close our copy of the original process descriptor.
     close(pd_);
     SEND_INT_MESSAGE(sock_fds[0], MSG_CHILD_STARTED);
@@ -992,7 +994,7 @@ TEST_F(PipePdfork, PassProcessDescriptor) {
     EXPECT_OK(rc);
     EXPECT_LE(CMSG_LEN(sizeof(int)), mh.msg_controllen);
     cmptr = CMSG_FIRSTHDR(&mh);
-    int pd = *(int*)CMSG_DATA(cmptr);
+    memcpy(&pd, CMSG_DATA(cmptr), sizeof(pd));
     EXPECT_EQ(CMSG_LEN(sizeof(int)), cmptr->cmsg_len);
     cmptr = CMSG_NXTHDR(&mh, cmptr);
     EXPECT_TRUE(cmptr == NULL);
@@ -1024,7 +1026,7 @@ TEST_F(PipePdfork, PassProcessDescriptor) {
   cmptr->cmsg_level = SOL_SOCKET;
   cmptr->cmsg_type = SCM_RIGHTS;
   cmptr->cmsg_len = CMSG_LEN(sizeof(int));
-  *(int *)CMSG_DATA(cmptr) = pd_;
+  memcpy(CMSG_DATA(cmptr), &pd_, sizeof(pd_));
   buffer1[0] = 0;
   iov[0].iov_len = 1;
   if (verbose) fprintf(stderr, "[%d] send process descriptor %d on socket\n", getpid_(), pd_);
diff --git a/tests/sys/capsicum/sctp.cc b/tests/sys/capsicum/sctp.cc
index aa84653c5b2a..71da1388aa8d 100644
--- a/tests/sys/capsicum/sctp.cc
+++ b/tests/sys/capsicum/sctp.cc
@@ -92,13 +92,13 @@ TEST(Sctp, Socket) {
   addr.sin_family = AF_INET;
   addr.sin_port = htons(0);
   addr.sin_addr.s_addr = htonl(INADDR_ANY);
-  socklen_t len = sizeof(addr);
+  socklen_t srv_addr_len = sizeof(addr);
 
   // Can only bind the fully-capable socket.
-  EXPECT_NOTCAPABLE(bind(cap_sock_rw, (struct sockaddr *)&addr, len));
-  EXPECT_OK(bind(cap_sock_all, (struct sockaddr *)&addr, len));
+  EXPECT_NOTCAPABLE(bind(cap_sock_rw, (struct sockaddr *)&addr, srv_addr_len));
+  EXPECT_OK(bind(cap_sock_all, (struct sockaddr *)&addr, srv_addr_len));
 
-  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&addr, &len));
+  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&addr, &srv_addr_len));
   int port = ntohs(addr.sin_port);
 
   // Now we know the port involved, fork off children to run clients.
@@ -128,26 +128,26 @@ TEST(Sctp, Socket) {
   EXPECT_OK(listen(cap_sock_all, 3));
 
   // Can only do socket operations on the fully-capable socket.
-  len = sizeof(addr);
-  EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &len));
+  srv_addr_len = sizeof(addr);
+  EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &srv_addr_len));
 
   struct sctp_event_subscribe events;
   memset(&events, 0, sizeof(events));
   events.sctp_association_event = 1;
   events.sctp_data_io_event = 1;
   EXPECT_NOTCAPABLE(setsockopt(cap_sock_rw, IPPROTO_SCTP, SCTP_EVENTS, &events, sizeof(events)));
-  len = sizeof(events);
-  EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, IPPROTO_SCTP, SCTP_EVENTS, &events, &len));
+  socklen_t eventslen = sizeof(events);
+  EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, IPPROTO_SCTP, SCTP_EVENTS, &events, &eventslen));
   memset(&events, 0, sizeof(events));
   events.sctp_association_event = 1;
   events.sctp_data_io_event = 1;
   EXPECT_OK(setsockopt(cap_sock_all, IPPROTO_SCTP, SCTP_EVENTS, &events, sizeof(events)));
-  len = sizeof(events);
-  EXPECT_OK(getsockopt(cap_sock_all, IPPROTO_SCTP, SCTP_EVENTS, &events, &len));
+  eventslen = sizeof(events);
+  EXPECT_OK(getsockopt(cap_sock_all, IPPROTO_SCTP, SCTP_EVENTS, &events, &eventslen));
 
-  len = sizeof(addr);
+  srv_addr_len = sizeof(addr);
   memset(&addr, 0, sizeof(addr));
-  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&addr, &len));
+  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&addr, &srv_addr_len));
   EXPECT_EQ(AF_INET, addr.sin_family);
   EXPECT_EQ(htons(port), addr.sin_port);
 
diff --git a/tests/sys/capsicum/socket.cc b/tests/sys/capsicum/socket.cc
index 5bb7e9d3e180..9ebab00d8404 100644
--- a/tests/sys/capsicum/socket.cc
+++ b/tests/sys/capsicum/socket.cc
@@ -166,26 +166,26 @@ TEST(Socket, TCP) {
     AWAIT_INT_MESSAGE(pipefds[1], MSG_PARENT_CHILD_SHOULD_RUN);
 
     // Create sockets
-    int sock = socket(AF_INET, SOCK_STREAM, 0);
-    EXPECT_OK(sock);
-    if (sock < 0) return;
-    int cap_sock_rw = dup(sock);
+    int sock2 = socket(AF_INET, SOCK_STREAM, 0);
+    EXPECT_OK(sock2);
+    if (sock2 < 0) return;
+    int cap_sock_rw2 = dup(sock2);
     EXPECT_OK(cap_sock_rw);
-    EXPECT_OK(cap_rights_limit(cap_sock_rw, &r_rw));
-    int cap_sock_all = dup(sock);
+    EXPECT_OK(cap_rights_limit(cap_sock_rw2, &r_rw));
+    int cap_sock_all2 = dup(sock2);
     EXPECT_OK(cap_sock_all);
     EXPECT_OK(cap_rights_limit(cap_sock_all, &r_all));
-    close(sock);
+    close(sock2);
 
     // Connect socket
-    struct sockaddr_in addr;
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);  // Pick unused port
-    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-    socklen_t len = sizeof(addr);
-    EXPECT_NOTCAPABLE(connect_(cap_sock_rw, (struct sockaddr *)&addr, len));
-    EXPECT_OK(connect_(cap_sock_all, (struct sockaddr *)&addr, len));
+    struct sockaddr_in addr2;
+    memset(&addr2, 0, sizeof(addr2));
+    addr2.sin_family = AF_INET;
+    addr2.sin_port = htons(port);  // Pick unused port
+    addr2.sin_addr.s_addr = inet_addr("127.0.0.1");
+    socklen_t len2 = sizeof(addr2);
+    EXPECT_NOTCAPABLE(connect_(cap_sock_rw2, (struct sockaddr *)&addr2, len2));
+    EXPECT_OK(connect_(cap_sock_all2, (struct sockaddr *)&addr2, len2));
 
     exit(HasFailure());
   }
@@ -291,15 +291,15 @@ TEST(Socket, UDP) {
 
   pid_t child = fork();
   if (child == 0) {
-    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    int sock2 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     EXPECT_OK(sock);
-    int cap_sock_rw = dup(sock);
-    EXPECT_OK(cap_sock_rw);
-    EXPECT_OK(cap_rights_limit(cap_sock_rw, &r_rw));
-    int cap_sock_connect = dup(sock);
+    int cap_sock_rw2 = dup(sock2);
+    EXPECT_OK(cap_sock_rw2);
+    EXPECT_OK(cap_rights_limit(cap_sock_rw2, &r_rw));
+    int cap_sock_connect = dup(sock2);
     EXPECT_OK(cap_sock_connect);
     EXPECT_OK(cap_rights_limit(cap_sock_connect, &r_connect));
-    close(sock);
+    close(sock2);
 
     // Can only sendmsg(2) to an address over a socket with CAP_CONNECT.
     unsigned char buffer[256];
@@ -313,13 +313,13 @@ TEST(Socket, UDP) {
     mh.msg_iov = &iov;
     mh.msg_iovlen = 1;
 
-    struct sockaddr_in addr;
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);
-    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-    mh.msg_name = &addr;
-    mh.msg_namelen = sizeof(addr);
+    struct sockaddr_in addr2;
+    memset(&addr, 0, sizeof(addr2));
+    addr2.sin_family = AF_INET;
+    addr2.sin_port = htons(port);
+    addr2.sin_addr.s_addr = inet_addr("127.0.0.1");
+    mh.msg_name = &addr2;
+    mh.msg_namelen = sizeof(addr2);
 
     EXPECT_NOTCAPABLE(sendmsg(cap_sock_rw, &mh, 0));
     EXPECT_OK(sendmsg(cap_sock_connect, &mh, 0));
@@ -328,7 +328,7 @@ TEST(Socket, UDP) {
     struct mmsghdr mv;
     memset(&mv, 0, sizeof(mv));
     memcpy(&mv.msg_hdr, &mh, sizeof(struct msghdr));
-    EXPECT_NOTCAPABLE(sendmmsg(cap_sock_rw, &mv, 1, 0));
+    EXPECT_NOTCAPABLE(sendmmsg(child_cap_sock_rw, &mv, 1, 0));
     EXPECT_OK(sendmmsg(cap_sock_connect, &mv, 1, 0));
 #endif
     close(cap_sock_rw);