git: ab6a3f137c33 - main - Revert "capsicum-test: make the code WARNS=6 clean"

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

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

commit ab6a3f137c33d96d15f703bd451589adee067883
Author:     Enji Cooper <ngie@FreeBSD.org>
AuthorDate: 2026-11-10 01:50:09 +0000
Commit:     Enji Cooper <ngie@FreeBSD.org>
CommitDate: 2026-11-10 01:50:09 +0000

    Revert "capsicum-test: make the code WARNS=6 clean"
    
    The wrong patch got committed somehow from one of my git clones. Revert the
    change so I can reapply the correct patch >:(.
    
    This reverts commit 5bae837f316ca96b69c61bae15bd61da76e7f3ea.
---
 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, 66 insertions(+), 84 deletions(-)

diff --git a/tests/sys/capsicum/Makefile b/tests/sys/capsicum/Makefile
index 9a88c9cf0ec1..788fa9f9394c 100644
--- a/tests/sys/capsicum/Makefile
+++ b/tests/sys/capsicum/Makefile
@@ -56,6 +56,8 @@ 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 5a153d827e2c..a9e4d30ac4b9 100644
--- a/tests/sys/capsicum/capability-fd.cc
+++ b/tests/sys/capsicum/capability-fd.cc
@@ -974,8 +974,6 @@ 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
@@ -986,16 +984,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);
-    memcpy(&cap_fd2, CMSG_DATA(cmptr), sizeof(cap_fd2));
+    int cap_fd = *(int*)CMSG_DATA(cmptr);
     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_fd2, &rights));
+    EXPECT_OK(cap_rights_get(cap_fd, &rights));
     EXPECT_RIGHTS_EQ(&r_rs, &rights);
-    TryReadWrite(cap_fd2);
+    TryReadWrite(cap_fd);
 
     // Child: acknowledge that we have received and tested the file descriptor
     SEND_INT_MESSAGE(sock_fds[0], MSG_CHILD_FD_RECEIVED);
@@ -1026,7 +1024,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));
-  memcpy(CMSG_DATA(cmptr), &cap_fd, sizeof(cap_fd));
+  *(int *)CMSG_DATA(cmptr) = 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 4cf6f24420e3..fdc572f11b5b 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 = 'a';
+  char ch;
   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 5503a7ef260f..7433814b31c8 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) do {    \
+#define _RUN_FORKED(INNERCODE, TESTCASENAME, TESTNAME)         \
     pid_t pid = force_nofork ? 0 : fork();                     \
     if (pid == 0) {                                            \
       INNERCODE;                                               \
@@ -95,13 +95,10 @@ const char *TmpFile(const char *pathname);
                         strerror(errno), errno);               \
         ADD_FAILURE() << "Failed to wait for child";           \
       } else {                                                 \
-        int exit_status =                                      \
-          WIFEXITED(status) ? WEXITSTATUS(status) : -1;        \
-        EXPECT_EQ(0, exit_status);                             \
+        int rc = WIFEXITED(status) ? WEXITSTATUS(status) : -1; \
+        EXPECT_EQ(0, rc);                                      \
       }                                                        \
-    }                                                          \
-} while (0)
-
+    }
 #define _RUN_FORKED_MEM(THIS, TESTFN, TESTCASENAME, TESTNAME)  \
   _RUN_FORKED(MaybeRunWithThread(THIS, &TESTFN), TESTCASENAME, TESTNAME);
 #define _RUN_FORKED_FN(TESTFN, TESTCASENAME, TESTNAME)   \
@@ -140,28 +137,15 @@ 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 (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) \
+// Expect a syscall to fail with the given error.
+#define EXPECT_SYSCALL_FAIL(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 { \
@@ -185,9 +169,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_NO_TRACE(E_NO_TRAVERSE_O_BENEATH, result); \
+        EXPECT_SYSCALL_FAIL(E_NO_TRAVERSE_O_BENEATH, result); \
       } else { \
-        EXPECT_SYSCALL_FAIL_NO_TRACE(E_NO_TRAVERSE_CAPABILITY, result); \
+        EXPECT_SYSCALL_FAIL(E_NO_TRAVERSE_CAPABILITY, result); \
       } \
       if (result >= 0) { close(result); } \
     } while (0)
@@ -196,7 +180,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_NO_TRACE(E_NO_TRAVERSE_CAPABILITY, result); \
+      EXPECT_SYSCALL_FAIL(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 6ff5a657c35a..86df2af06388 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] = __DECONST(char*, exec_prog_.c_str());
-    argv_fail_[0] = __DECONST(char*, exec_prog_.c_str());
-    argv_pass_[0] = __DECONST(char*, 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();
   }
   ~Execve() {
     if (exec_fd_ >= 0) {
@@ -43,9 +43,9 @@ class Execve : public ::testing::Test {
     }
   }
 protected:
-  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};
+  char* argv_checkroot_[3] = {nullptr, (char*)"--checkroot", nullptr};
+  char* argv_fail_[3] = {nullptr, (char*)"--fail", nullptr};
+  char* argv_pass_[3] = {nullptr, (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 c92edaf4b695..f25324e4efc7 100644
--- a/tests/sys/capsicum/procdesc.cc
+++ b/tests/sys/capsicum/procdesc.cc
@@ -983,8 +983,6 @@ 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);
@@ -994,7 +992,7 @@ TEST_F(PipePdfork, PassProcessDescriptor) {
     EXPECT_OK(rc);
     EXPECT_LE(CMSG_LEN(sizeof(int)), mh.msg_controllen);
     cmptr = CMSG_FIRSTHDR(&mh);
-    memcpy(&pd, CMSG_DATA(cmptr), sizeof(pd));
+    int pd = *(int*)CMSG_DATA(cmptr);
     EXPECT_EQ(CMSG_LEN(sizeof(int)), cmptr->cmsg_len);
     cmptr = CMSG_NXTHDR(&mh, cmptr);
     EXPECT_TRUE(cmptr == NULL);
@@ -1026,7 +1024,7 @@ TEST_F(PipePdfork, PassProcessDescriptor) {
   cmptr->cmsg_level = SOL_SOCKET;
   cmptr->cmsg_type = SCM_RIGHTS;
   cmptr->cmsg_len = CMSG_LEN(sizeof(int));
-  memcpy(CMSG_DATA(cmptr), &pd_, sizeof(pd_));
+  *(int *)CMSG_DATA(cmptr) = 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 71da1388aa8d..aa84653c5b2a 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 srv_addr_len = sizeof(addr);
+  socklen_t len = sizeof(addr);
 
   // Can only bind the fully-capable socket.
-  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_NOTCAPABLE(bind(cap_sock_rw, (struct sockaddr *)&addr, len));
+  EXPECT_OK(bind(cap_sock_all, (struct sockaddr *)&addr, len));
 
-  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&addr, &srv_addr_len));
+  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&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.
-  srv_addr_len = sizeof(addr);
-  EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &srv_addr_len));
+  len = sizeof(addr);
+  EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&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)));
-  socklen_t eventslen = sizeof(events);
-  EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, IPPROTO_SCTP, SCTP_EVENTS, &events, &eventslen));
+  len = sizeof(events);
+  EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, IPPROTO_SCTP, SCTP_EVENTS, &events, &len));
   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)));
-  eventslen = sizeof(events);
-  EXPECT_OK(getsockopt(cap_sock_all, IPPROTO_SCTP, SCTP_EVENTS, &events, &eventslen));
+  len = sizeof(events);
+  EXPECT_OK(getsockopt(cap_sock_all, IPPROTO_SCTP, SCTP_EVENTS, &events, &len));
 
-  srv_addr_len = sizeof(addr);
+  len = sizeof(addr);
   memset(&addr, 0, sizeof(addr));
-  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&addr, &srv_addr_len));
+  EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&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 9ebab00d8404..5bb7e9d3e180 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 sock2 = socket(AF_INET, SOCK_STREAM, 0);
-    EXPECT_OK(sock2);
-    if (sock2 < 0) return;
-    int cap_sock_rw2 = dup(sock2);
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    EXPECT_OK(sock);
+    if (sock < 0) return;
+    int cap_sock_rw = dup(sock);
     EXPECT_OK(cap_sock_rw);
-    EXPECT_OK(cap_rights_limit(cap_sock_rw2, &r_rw));
-    int cap_sock_all2 = dup(sock2);
+    EXPECT_OK(cap_rights_limit(cap_sock_rw, &r_rw));
+    int cap_sock_all = dup(sock);
     EXPECT_OK(cap_sock_all);
     EXPECT_OK(cap_rights_limit(cap_sock_all, &r_all));
-    close(sock2);
+    close(sock);
 
     // Connect socket
-    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));
+    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));
 
     exit(HasFailure());
   }
@@ -291,15 +291,15 @@ TEST(Socket, UDP) {
 
   pid_t child = fork();
   if (child == 0) {
-    int sock2 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
     EXPECT_OK(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);
+    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);
     EXPECT_OK(cap_sock_connect);
     EXPECT_OK(cap_rights_limit(cap_sock_connect, &r_connect));
-    close(sock2);
+    close(sock);
 
     // 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 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);
+    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);
 
     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(child_cap_sock_rw, &mv, 1, 0));
+    EXPECT_NOTCAPABLE(sendmmsg(cap_sock_rw, &mv, 1, 0));
     EXPECT_OK(sendmmsg(cap_sock_connect, &mv, 1, 0));
 #endif
     close(cap_sock_rw);