Add SO_PASSCRED_THREAD tests to the af_unix scm_pidfd selftests. Signed-off-by: Andrew Halaney --- tools/testing/selftests/net/af_unix/scm_pidfd.c | 160 +++++++++++++++++++++++- 1 file changed, 156 insertions(+), 4 deletions(-) diff --git a/tools/testing/selftests/net/af_unix/scm_pidfd.c b/tools/testing/selftests/net/af_unix/scm_pidfd.c index 7524f3f6a8aa..75387ede1eeb 100644 --- a/tools/testing/selftests/net/af_unix/scm_pidfd.c +++ b/tools/testing/selftests/net/af_unix/scm_pidfd.c @@ -40,6 +40,14 @@ #define SO_PEERPIDFD_THREAD 87 #endif +#ifndef SO_PASSCRED_THREAD +#define SO_PASSCRED_THREAD 88 +#endif + +#ifndef SCM_CREDENTIALS_THREAD +#define SCM_CREDENTIALS_THREAD 0x06 +#endif + #define CHILD_EXIT_CODE_OK 123 static void child_die() @@ -689,6 +697,10 @@ struct pidfd_msg { int thread_flags; bool have_tgid; bool have_thread; + struct ucred creds; + struct ucred thread_creds; + bool have_creds; + bool have_thread_creds; }; static int get_pidfd_info(int pidfd, struct pidfd_info *info) @@ -703,11 +715,12 @@ static int get_pidfd_info(int pidfd, struct pidfd_info *info) } /* One recvmsg(), reporting how many bytes came back and what the pidfd - * cmsgs that came with them say. + * and credentials cmsgs that came with them say. */ static int read_pidfd_msg(int fd, struct pidfd_msg *out) { - char control[CMSG_SPACE(sizeof(int)) * 2] = { 0 }; + char control[CMSG_SPACE(sizeof(int)) * 2 + + CMSG_SPACE(sizeof(struct ucred)) * 2] = { 0 }; int tgid_pidfd = -1, thread_pidfd = -1; struct thread_ids buf[2] = { 0 }; struct msghdr msg = { 0 }; @@ -739,10 +752,18 @@ static int read_pidfd_msg(int fd, struct pidfd_msg *out) if (cmsg->cmsg_level != SOL_SOCKET) continue; - if (cmsg->cmsg_type == SCM_PIDFD) + if (cmsg->cmsg_type == SCM_PIDFD) { memcpy(&tgid_pidfd, CMSG_DATA(cmsg), sizeof(tgid_pidfd)); - else if (cmsg->cmsg_type == SCM_PIDFD_THREAD) + } else if (cmsg->cmsg_type == SCM_PIDFD_THREAD) { memcpy(&thread_pidfd, CMSG_DATA(cmsg), sizeof(thread_pidfd)); + } else if (cmsg->cmsg_type == SCM_CREDENTIALS) { + memcpy(&out->creds, CMSG_DATA(cmsg), sizeof(out->creds)); + out->have_creds = true; + } else if (cmsg->cmsg_type == SCM_CREDENTIALS_THREAD) { + memcpy(&out->thread_creds, CMSG_DATA(cmsg), + sizeof(out->thread_creds)); + out->have_thread_creds = true; + } } out->have_tgid = tgid_pidfd >= 0; @@ -769,6 +790,9 @@ static int read_pidfd_msg(int fd, struct pidfd_msg *out) static const int pass_tgid[] = { SO_PASSPIDFD, 0 }; static const int pass_thread[] = { SO_PASSPIDFD_THREAD, 0 }; static const int pass_both[] = { SO_PASSPIDFD, SO_PASSPIDFD_THREAD, 0 }; +static const int creds_tgid[] = { SO_PASSCRED, 0 }; +static const int creds_thread[] = { SO_PASSCRED_THREAD, 0 }; +static const int creds_both[] = { SO_PASSCRED, SO_PASSCRED_THREAD, 0 }; static int set_opts(int fd, const int *opts) { @@ -1061,6 +1085,134 @@ TEST(scm_pidfd_thread_creds) EXPECT_EQ(msg.ids.pid, msg.thread_info.tgid); } +TEST(scm_creds_thread_setsockopt_values) +{ + int sk[2]; + int inet; + + ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sk)); + + /* Verify that the options are truly set independently */ + ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED_THREAD, 1)); + ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD)); + ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED)); + + ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED, 1)); + ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED)); + ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD)); + + /* Verify that the options are truly cleared independently */ + ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED, 0)); + ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED)); + ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD)); + + ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED_THREAD, 0)); + ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED_THREAD)); + ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED)); + + close(sk[0]); + close(sk[1]); + + /* Only AF_UNIX records the sending thread */ + inet = socket(AF_INET, SOCK_DGRAM, 0); + ASSERT_LE(0, inet); + EXPECT_EQ(-1, sockopt_set(inet, SO_PASSCRED_THREAD, 1)); + EXPECT_EQ(EOPNOTSUPP, errno); + close(inet); +} + +/* A receiver that only asked about the process cannot tell the two + * threads apart, so their writes are glued into one read. + */ +TEST(scm_creds_stream_glues_threads) +{ + struct pidfd_msg msg[1] = { 0 }; + + ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, creds_tgid, msg, 1)); + EXPECT_EQ(sizeof(struct thread_ids) * 2, msg[0].len); + + EXPECT_TRUE(msg[0].have_creds); + EXPECT_FALSE(msg[0].have_thread_creds); + EXPECT_EQ(msg[0].ids.pid, msg[0].creds.pid); +} + +/* SO_PASSCRED_THREAD on its own is enough to split a stream per thread */ +TEST(scm_creds_thread_stream_splits_on_threads) +{ + struct pidfd_msg msg[2] = { 0 }; + int i; + + ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, creds_thread, msg, 2)); + + for (i = 0; i < 2; i++) { + EXPECT_EQ(sizeof(struct thread_ids), msg[i].len); + EXPECT_FALSE(msg[i].have_creds); + EXPECT_TRUE(msg[i].have_thread_creds); + EXPECT_NE(msg[i].ids.pid, msg[i].ids.tid); + EXPECT_EQ(msg[i].ids.tid, msg[i].thread_creds.pid); + } + + /* Make sure we really got unique threads per message */ + EXPECT_NE(msg[0].thread_creds.pid, msg[1].thread_creds.pid); +} + +TEST(scm_creds_thread_leader_sender) +{ + struct pidfd_msg msg = { 0 }; + + ASSERT_EQ(getpid(), gettid()); + + ASSERT_EQ(0, leader_flow(creds_both, &msg)); + ASSERT_TRUE(msg.have_creds); + ASSERT_TRUE(msg.have_thread_creds); + + EXPECT_EQ(getpid(), msg.creds.pid); + EXPECT_EQ(getpid(), msg.thread_creds.pid); +} + +TEST(scm_creds_thread_and_group) +{ + struct pidfd_msg msg = { 0 }; + + ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, creds_both, &msg, 1)); + ASSERT_NE(msg.ids.pid, msg.ids.tid); + ASSERT_TRUE(msg.have_creds); + ASSERT_TRUE(msg.have_thread_creds); + + EXPECT_EQ(msg.ids.pid, msg.creds.pid); + EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid); + EXPECT_EQ(msg.creds.uid, msg.thread_creds.uid); + EXPECT_EQ(msg.creds.gid, msg.thread_creds.gid); +} + +TEST(scm_creds_thread) +{ + struct pidfd_msg msg = { 0 }; + + ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, creds_thread, &msg, 1)); + ASSERT_NE(msg.ids.pid, msg.ids.tid); + ASSERT_TRUE(msg.have_thread_creds); + EXPECT_FALSE(msg.have_creds); + + EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid); + EXPECT_EQ(getuid(), msg.thread_creds.uid); + EXPECT_EQ(getgid(), msg.thread_creds.gid); +} + +/* A sender passing its own SCM_CREDENTIALS still reports the sending thread */ +TEST(scm_creds_thread_explicit_creds) +{ + struct pidfd_msg msg = { 0 }; + + ASSERT_EQ(0, pidfd_flow(send_ids_creds_thread, 1, creds_both, &msg, 1)); + ASSERT_NE(msg.ids.pid, msg.ids.tid); + ASSERT_TRUE(msg.have_creds); + ASSERT_TRUE(msg.have_thread_creds); + + EXPECT_EQ(msg.ids.pid, msg.creds.pid); + EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid); +} + static void *peer_connect_thread(void *arg) { struct sock_addr *sa = arg; -- 2.56.0