Page MenuHomeFreeBSD
Files F177541786

D61080.1794671497.diff
No OneTemporary
Actions

Authored By
Unknown
Size
25 KB
Referenced Files
None
Subscribers
None

D61080.1794671497.diff
View Options

diff --git a/tests/sys/capsicum/capability-fd.cc b/tests/sys/capsicum/capability-fd.cc
--- a/tests/sys/capsicum/capability-fd.cc
+++ b/tests/sys/capsicum/capability-fd.cc
@@ -974,6 +974,8 @@
pid_t child = fork();
if (child == 0) {
+ int child_cap_fd;
+
// Child: enter cap mode
EXPECT_OK(cap_enter());
// Child: send startup notification
@@ -984,16 +986,16 @@
EXPECT_OK(rc);
EXPECT_LE(CMSG_LEN(sizeof(int)), mh.msg_controllen);
cmptr = CMSG_FIRSTHDR(&mh);
- int cap_fd = *(int*)CMSG_DATA(cmptr);
+ memcpy(&child_cap_fd, CMSG_DATA(cmptr), sizeof(child_cap_fd));
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(child_cap_fd, &rights));
EXPECT_RIGHTS_EQ(&r_rs, &rights);
- TryReadWrite(cap_fd);
+ TryReadWrite(child_cap_fd);
// 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 @@
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
--- a/tests/sys/capsicum/capmode.cc
+++ b/tests/sys/capsicum/capmode.cc
@@ -158,7 +158,7 @@
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-main.cc b/tests/sys/capsicum/capsicum-test-main.cc
--- a/tests/sys/capsicum/capsicum-test-main.cc
+++ b/tests/sys/capsicum/capsicum-test-main.cc
@@ -75,12 +75,15 @@
// Adds a directory to $PATH.
static void AddDirectoryToPath(const char *dir) {
char *new_path, *old_path;
+ int rc [[maybe_unused]];
old_path = getenv("PATH");
assert(old_path);
- assert(asprintf(&new_path, "%s:%s", dir, old_path) > 0);
- assert(setenv("PATH", new_path, 1) == 0);
+ rc = asprintf(&new_path, "%s:%s", dir, old_path);
+ assert(rc != -1);
+ rc = setenv("PATH", new_path, 1);
+ assert(rc == 0);
}
int main(int argc, char* argv[]) {
diff --git a/tests/sys/capsicum/capsicum-test.h b/tests/sys/capsicum/capsicum-test.h
--- a/tests/sys/capsicum/capsicum-test.h
+++ b/tests/sys/capsicum/capsicum-test.h
@@ -67,7 +67,7 @@
// 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 @@
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 @@
// 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 @@
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 @@
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
--- a/tests/sys/capsicum/fexecve.cc
+++ b/tests/sys/capsicum/fexecve.cc
@@ -32,9 +32,9 @@
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 @@
}
}
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
--- a/tests/sys/capsicum/procdesc.cc
+++ b/tests/sys/capsicum/procdesc.cc
@@ -983,6 +983,8 @@
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 @@
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 @@
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
--- a/tests/sys/capsicum/sctp.cc
+++ b/tests/sys/capsicum/sctp.cc
@@ -92,13 +92,13 @@
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 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, addr_len));
+ EXPECT_OK(bind(cap_sock_all, (struct sockaddr *)&addr, addr_len));
- EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&addr, &len));
+ EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr *)&addr, &addr_len));
int port = ntohs(addr.sin_port);
// Now we know the port involved, fork off children to run clients.
@@ -128,43 +128,43 @@
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));
+ addr_len = sizeof(addr);
+ EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &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);
+ 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, &addr_len));
EXPECT_EQ(AF_INET, addr.sin_family);
EXPECT_EQ(htons(port), addr.sin_port);
struct sockaddr_in client_addr;
- socklen_t addr_len = sizeof(client_addr);
+ socklen_t client_addr_len = sizeof(client_addr);
unsigned char buffer[1024];
struct sctp_sndrcvinfo sri;
memset(&sri, 0, sizeof(sri));
int flags = 0;
EXPECT_NOTCAPABLE(sctp_recvmsg(cap_sock_wo, buffer, sizeof(buffer),
- (struct sockaddr*)&client_addr, &addr_len,
+ (struct sockaddr*)&client_addr, &client_addr_len,
&sri, &flags));
while (true) {
retry:
memset(&sri, 0, sizeof(sri));
int len = sctp_recvmsg(cap_sock_rw, buffer, sizeof(buffer),
- (struct sockaddr*)&client_addr, &addr_len,
+ (struct sockaddr*)&client_addr, &client_addr_len,
&sri, &flags);
if (len < 0 && errno == EAGAIN) goto retry;
EXPECT_OK(len);
diff --git a/tests/sys/capsicum/socket.cc b/tests/sys/capsicum/socket.cc
--- a/tests/sys/capsicum/socket.cc
+++ b/tests/sys/capsicum/socket.cc
@@ -33,9 +33,9 @@
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_rw, &r_rw));
+ int sock_rw_cap = dup(sock);
+ EXPECT_OK(sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(sock_rw_cap, &r_rw));
int cap_sock_all = dup(sock);
EXPECT_OK(cap_sock_all);
EXPECT_OK(cap_rights_limit(cap_sock_all, &r_all));
@@ -47,7 +47,7 @@
un.sun_family = AF_UNIX;
strcpy(un.sun_path, socketName);
socklen_t len = sizeof(un);
- EXPECT_NOTCAPABLE(connect_(cap_sock_rw, (struct sockaddr *)&un, len));
+ EXPECT_NOTCAPABLE(connect_(sock_rw_cap, (struct sockaddr *)&un, len));
EXPECT_OK(connect_(cap_sock_all, (struct sockaddr *)&un, len));
exit(HasFailure());
@@ -57,9 +57,9 @@
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_rw, &r_rw));
+ int sock_rw_cap = dup(sock);
+ EXPECT_OK(sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(sock_rw_cap, &r_rw));
int cap_sock_all = dup(sock);
EXPECT_OK(cap_sock_all);
EXPECT_OK(cap_rights_limit(cap_sock_all, &r_all));
@@ -72,20 +72,20 @@
socklen_t len = (sizeof(un) - sizeof(un.sun_path) + strlen(un.sun_path));
// Can only bind the fully-capable socket.
- EXPECT_NOTCAPABLE(bind_(cap_sock_rw, (struct sockaddr *)&un, len));
+ EXPECT_NOTCAPABLE(bind_(sock_rw_cap, (struct sockaddr *)&un, len));
EXPECT_OK(bind_(cap_sock_all, (struct sockaddr *)&un, len));
// Can only listen on the fully-capable socket.
- EXPECT_NOTCAPABLE(listen(cap_sock_rw, 3));
+ EXPECT_NOTCAPABLE(listen(sock_rw_cap, 3));
EXPECT_OK(listen(cap_sock_all, 3));
// Can only do socket operations on the fully-capable socket.
len = sizeof(un);
- EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&un, &len));
+ EXPECT_NOTCAPABLE(getsockname(sock_rw_cap, (struct sockaddr*)&un, &len));
int value = 0;
- EXPECT_NOTCAPABLE(setsockopt(cap_sock_rw, SOL_SOCKET, SO_DEBUG, &value, sizeof(value)));
+ EXPECT_NOTCAPABLE(setsockopt(sock_rw_cap, SOL_SOCKET, SO_DEBUG, &value, sizeof(value)));
len = sizeof(value);
- EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, SOL_SOCKET, SO_DEBUG, &value, &len));
+ EXPECT_NOTCAPABLE(getsockopt(sock_rw_cap, SOL_SOCKET, SO_DEBUG, &value, &len));
len = sizeof(un);
memset(&un, 0, sizeof(un));
@@ -102,7 +102,7 @@
SEND_INT_MESSAGE(pipefds[0], MSG_PARENT_CHILD_SHOULD_RUN);
len = sizeof(un);
memset(&un, 0, sizeof(un));
- EXPECT_NOTCAPABLE(accept(cap_sock_rw, (struct sockaddr *)&un, &len));
+ EXPECT_NOTCAPABLE(accept(sock_rw_cap, (struct sockaddr *)&un, &len));
int conn_fd = accept(cap_sock_all, (struct sockaddr *)&un, &len);
EXPECT_OK(conn_fd);
@@ -119,7 +119,7 @@
EXPECT_EQ(0, rc);
close(conn_fd);
- close(cap_sock_rw);
+ close(sock_rw_cap);
close(cap_sock_all);
unlink(socketName);
}
@@ -134,12 +134,12 @@
cap_rights_t r_all;
cap_rights_init(&r_all, CAP_READ, CAP_WRITE, CAP_SOCK_CLIENT, CAP_SOCK_SERVER);
- int cap_sock_rw = dup(sock);
- EXPECT_OK(cap_sock_rw);
- 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));
+ int server_sock_rw_cap = dup(sock);
+ EXPECT_OK(server_sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(server_sock_rw_cap, &r_rw));
+ int server_sock_all_cap = dup(sock);
+ EXPECT_OK(server_sock_all_cap);
+ EXPECT_OK(cap_rights_limit(server_sock_all_cap, &r_all));
close(sock);
struct sockaddr_in addr;
@@ -150,10 +150,10 @@
socklen_t 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_(server_sock_rw_cap, (struct sockaddr *)&addr, len));
+ EXPECT_OK(bind_(server_sock_all_cap, (struct sockaddr *)&addr, len));
- getsockname(cap_sock_all, (struct sockaddr *)&addr, &len);
+ getsockname(server_sock_all_cap, (struct sockaddr *)&addr, &len);
int port = ntohs(addr.sin_port);
int pipefds[2];
@@ -166,59 +166,59 @@
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);
- EXPECT_OK(cap_sock_rw);
- 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(sock);
+ int client_sock = socket(AF_INET, SOCK_STREAM, 0);
+ EXPECT_OK(client_sock);
+ if (client_sock < 0) return;
+ int client_sock_rw_cap = dup(client_sock);
+ EXPECT_OK(client_sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(client_sock_rw_cap, &r_rw));
+ int child_sock_all_cap = dup(client_sock);
+ EXPECT_OK(child_sock_all_cap);
+ EXPECT_OK(cap_rights_limit(child_sock_all_cap, &r_all));
+ close(client_sock);
// 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 server_addr;
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = htons(port); // Pick unused port
+ server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+ socklen_t len2 = sizeof(server_addr);
+ EXPECT_NOTCAPABLE(connect_(client_sock_rw_cap, (struct sockaddr *)&server_addr, len2));
+ EXPECT_OK(connect_(child_sock_all_cap, (struct sockaddr *)&server_addr, len2));
exit(HasFailure());
}
// Can only listen on the fully-capable socket.
- EXPECT_NOTCAPABLE(listen(cap_sock_rw, 3));
- EXPECT_OK(listen(cap_sock_all, 3));
+ EXPECT_NOTCAPABLE(listen(server_sock_rw_cap, 3));
+ EXPECT_OK(listen(server_sock_all_cap, 3));
// Can only do socket operations on the fully-capable socket.
len = sizeof(addr);
- EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &len));
+ EXPECT_NOTCAPABLE(getsockname(server_sock_rw_cap, (struct sockaddr*)&addr, &len));
int value = 1;
- EXPECT_NOTCAPABLE(setsockopt(cap_sock_rw, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
+ EXPECT_NOTCAPABLE(setsockopt(server_sock_rw_cap, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
len = sizeof(value);
- EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, SOL_SOCKET, SO_REUSEPORT, &value, &len));
+ EXPECT_NOTCAPABLE(getsockopt(server_sock_rw_cap, SOL_SOCKET, SO_REUSEPORT, &value, &len));
len = sizeof(addr);
memset(&addr, 0, sizeof(addr));
- EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&addr, &len));
+ EXPECT_OK(getsockname(server_sock_all_cap, (struct sockaddr*)&addr, &len));
EXPECT_EQ(AF_INET, addr.sin_family);
EXPECT_EQ(htons(port), addr.sin_port);
value = 0;
- EXPECT_OK(setsockopt(cap_sock_all, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
+ EXPECT_OK(setsockopt(server_sock_all_cap, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
len = sizeof(value);
- EXPECT_OK(getsockopt(cap_sock_all, SOL_SOCKET, SO_REUSEPORT, &value, &len));
+ EXPECT_OK(getsockopt(server_sock_all_cap, SOL_SOCKET, SO_REUSEPORT, &value, &len));
// Tell the child process that we are ready and accept the incoming connection.
EXPECT_OK(close(pipefds[1]));
SEND_INT_MESSAGE(pipefds[0], MSG_PARENT_CHILD_SHOULD_RUN);
len = sizeof(addr);
memset(&addr, 0, sizeof(addr));
- EXPECT_NOTCAPABLE(accept(cap_sock_rw, (struct sockaddr *)&addr, &len));
- int conn_fd = accept(cap_sock_all, (struct sockaddr *)&addr, &len);
+ EXPECT_NOTCAPABLE(accept(server_sock_rw_cap, (struct sockaddr *)&addr, &len));
+ int conn_fd = accept(server_sock_all_cap, (struct sockaddr *)&addr, &len);
EXPECT_OK(conn_fd);
// New connection should also be a capability.
@@ -234,8 +234,8 @@
EXPECT_EQ(0, rc);
close(conn_fd);
- close(cap_sock_rw);
- close(cap_sock_all);
+ close(server_sock_rw_cap);
+ close(server_sock_all_cap);
}
TEST(Socket, UDP) {
@@ -250,12 +250,12 @@
cap_rights_t r_connect;
cap_rights_init(&r_connect, CAP_READ, CAP_WRITE, CAP_CONNECT);
- int cap_sock_rw = dup(sock);
- EXPECT_OK(cap_sock_rw);
- 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));
+ int sock_rw_cap = dup(sock);
+ EXPECT_OK(sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(sock_rw_cap, &r_rw));
+ int server_sock_all_cap = dup(sock);
+ EXPECT_OK(server_sock_all_cap);
+ EXPECT_OK(cap_rights_limit(server_sock_all_cap, &r_all));
close(sock);
struct sockaddr_in addr;
@@ -266,40 +266,40 @@
socklen_t 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));
- getsockname(cap_sock_all, (struct sockaddr *)&addr, &len);
+ EXPECT_NOTCAPABLE(bind_(sock_rw_cap, (struct sockaddr *)&addr, len));
+ EXPECT_OK(bind_(server_sock_all_cap, (struct sockaddr *)&addr, len));
+ getsockname(server_sock_all_cap, (struct sockaddr *)&addr, &len);
int port = ntohs(addr.sin_port);
// Can only do socket operations on the fully-capable socket.
len = sizeof(addr);
- EXPECT_NOTCAPABLE(getsockname(cap_sock_rw, (struct sockaddr*)&addr, &len));
+ EXPECT_NOTCAPABLE(getsockname(sock_rw_cap, (struct sockaddr*)&addr, &len));
int value = 1;
- EXPECT_NOTCAPABLE(setsockopt(cap_sock_rw, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
+ EXPECT_NOTCAPABLE(setsockopt(sock_rw_cap, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
len = sizeof(value);
- EXPECT_NOTCAPABLE(getsockopt(cap_sock_rw, SOL_SOCKET, SO_REUSEPORT, &value, &len));
+ EXPECT_NOTCAPABLE(getsockopt(sock_rw_cap, SOL_SOCKET, SO_REUSEPORT, &value, &len));
len = sizeof(addr);
memset(&addr, 0, sizeof(addr));
- EXPECT_OK(getsockname(cap_sock_all, (struct sockaddr*)&addr, &len));
+ EXPECT_OK(getsockname(server_sock_all_cap, (struct sockaddr*)&addr, &len));
EXPECT_EQ(AF_INET, addr.sin_family);
EXPECT_EQ(htons(port), addr.sin_port);
value = 1;
- EXPECT_OK(setsockopt(cap_sock_all, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
+ EXPECT_OK(setsockopt(server_sock_all_cap, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value)));
len = sizeof(value);
- EXPECT_OK(getsockopt(cap_sock_all, SOL_SOCKET, SO_REUSEPORT, &value, &len));
+ EXPECT_OK(getsockopt(server_sock_all_cap, SOL_SOCKET, SO_REUSEPORT, &value, &len));
pid_t child = fork();
if (child == 0) {
- int sock = 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);
- EXPECT_OK(cap_sock_connect);
- EXPECT_OK(cap_rights_limit(cap_sock_connect, &r_connect));
- close(sock);
+ int client_sock_all_cap = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+ EXPECT_OK(client_sock_all_cap);
+ int client_sock_rw_cap = dup(client_sock_all_cap);
+ EXPECT_OK(client_sock_rw_cap);
+ EXPECT_OK(cap_rights_limit(client_sock_rw_cap, &r_rw));
+ int client_sock_conn_cap = dup(client_sock_all_cap);
+ EXPECT_OK(client_sock_conn_cap);
+ EXPECT_OK(cap_rights_limit(client_sock_conn_cap, &r_connect));
+ close(client_sock_all_cap);
// Can only sendmsg(2) to an address over a socket with CAP_CONNECT.
unsigned char buffer[256];
@@ -313,26 +313,26 @@
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 server_addr;
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = htons(port);
+ server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+ mh.msg_name = &server_addr;
+ mh.msg_namelen = sizeof(server_addr);
- EXPECT_NOTCAPABLE(sendmsg(cap_sock_rw, &mh, 0));
- EXPECT_OK(sendmsg(cap_sock_connect, &mh, 0));
+ EXPECT_NOTCAPABLE(sendmsg(sock_rw_cap, &mh, 0));
+ EXPECT_OK(sendmsg(client_sock_conn_cap, &mh, 0));
#ifdef HAVE_SEND_RECV_MMSG
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_OK(sendmmsg(cap_sock_connect, &mv, 1, 0));
+ EXPECT_NOTCAPABLE(sendmmsg(sock_rw_cap, &mv, 1, 0));
+ EXPECT_OK(sendmmsg(client_sock_conn_cap, &mv, 1, 0));
#endif
- close(cap_sock_rw);
- close(cap_sock_connect);
+ close(sock_rw_cap);
+ close(client_sock_all_cap);
exit(HasFailure());
}
// Wait for the child.
@@ -341,6 +341,6 @@
int rc = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
EXPECT_EQ(0, rc);
- close(cap_sock_rw);
- close(cap_sock_all);
+ close(sock_rw_cap);
+ close(server_sock_all_cap);
}

File Metadata

Mime Type
text/plain
Expires
Sat, Nov 14, 3:51 PM (9 h, 34 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
41711923
Default Alt Text
D61080.1794671497.diff (25 KB)

Event Timeline