git: ab6a3f137c33 - main - Revert "capsicum-test: make the code WARNS=6 clean"
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
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);