gvisor.dev/gvisor@v0.0.0-20240520182842-f9d4d51c7e0f/test/syscalls/linux/unix_domain_socket_test_util.cc

// Copyright 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "test/syscalls/linux/unix_domain_socket_test_util.h"

#include <sys/un.h>

#include <vector>

#include "gtest/gtest.h"
#include "absl/strings/str_cat.h"
#include "test/util/test_util.h"

namespace gvisor {
namespace testing {

std::string DescribeUnixDomainSocketType(int type) {
  const char* type_str = nullptr;
  switch (type & ~(SOCK_NONBLOCK | SOCK_CLOEXEC)) {
    case SOCK_STREAM:
      type_str = "SOCK_STREAM";
      break;
    case SOCK_DGRAM:
      type_str = "SOCK_DGRAM";
      break;
    case SOCK_SEQPACKET:
      type_str = "SOCK_SEQPACKET";
      break;
  }
  if (!type_str) {
    return absl::StrCat("Unix domain socket with unknown type ", type);
  } else {
    return absl::StrCat(((type & SOCK_NONBLOCK) != 0) ? "non-blocking " : "",
                        ((type & SOCK_CLOEXEC) != 0) ? "close-on-exec " : "",
                        type_str, " Unix domain socket");
  }
}

SocketPairKind UnixDomainSocketPair(int type) {
  return SocketPairKind{DescribeUnixDomainSocketType(type), AF_UNIX, type, 0,
                        SyscallSocketPairCreator(AF_UNIX, type, 0)};
}

SocketPairKind FilesystemBoundUnixDomainSocketPair(int type) {
  std::string description = absl::StrCat(DescribeUnixDomainSocketType(type),
                                         " created with filesystem binding");
  if ((type & SOCK_DGRAM) == SOCK_DGRAM) {
    return SocketPairKind{
        description, AF_UNIX, type, 0,
        FilesystemBidirectionalBindSocketPairCreator(AF_UNIX, type, 0)};
  }
  return SocketPairKind{
      description, AF_UNIX, type, 0,
      FilesystemAcceptBindSocketPairCreator(AF_UNIX, type, 0)};
}

SocketPairKind AbstractBoundUnixDomainSocketPair(int type) {
  std::string description =
      absl::StrCat(DescribeUnixDomainSocketType(type),
                   " created with abstract namespace binding");
  if ((type & SOCK_DGRAM) == SOCK_DGRAM) {
    return SocketPairKind{
        description, AF_UNIX, type, 0,
        AbstractBidirectionalBindSocketPairCreator(AF_UNIX, type, 0)};
  }
  return SocketPairKind{description, AF_UNIX, type, 0,
                        AbstractAcceptBindSocketPairCreator(AF_UNIX, type, 0)};
}

SocketPairKind SocketpairGoferUnixDomainSocketPair(int type) {
  std::string description = absl::StrCat(DescribeUnixDomainSocketType(type),
                                         " created with the socketpair gofer");
  return SocketPairKind{description, AF_UNIX, type, 0,
                        SocketpairGoferSocketPairCreator(AF_UNIX, type, 0)};
}

SocketPairKind SocketpairGoferFileSocketPair(int type) {
  std::string description =
      absl::StrCat(((type & O_NONBLOCK) != 0) ? "non-blocking " : "",
                   ((type & O_CLOEXEC) != 0) ? "close-on-exec " : "",
                   "file socket created with the socketpair gofer");
  // The socketpair gofer always creates SOCK_STREAM sockets on open(2).
  return SocketPairKind{description, AF_UNIX, SOCK_STREAM, 0,
                        SocketpairGoferFileSocketPairCreator(type)};
}

SocketPairKind FilesystemUnboundUnixDomainSocketPair(int type) {
  return SocketPairKind{absl::StrCat(DescribeUnixDomainSocketType(type),
                                     " unbound with a filesystem address"),
                        AF_UNIX, type, 0,
                        FilesystemUnboundSocketPairCreator(AF_UNIX, type, 0)};
}

SocketPairKind AbstractUnboundUnixDomainSocketPair(int type) {
  return SocketPairKind{
      absl::StrCat(DescribeUnixDomainSocketType(type),
                   " unbound with an abstract namespace address"),
      AF_UNIX, type, 0, AbstractUnboundSocketPairCreator(AF_UNIX, type, 0)};
}

void SendSingleFD(int sock, int fd, char buf[], int buf_size) {
  ASSERT_NO_FATAL_FAILURE(SendFDs(sock, &fd, 1, buf, buf_size));
}

void SendFDs(int sock, int fds[], int fds_size, char buf[], int buf_size) {
  struct msghdr msg = {};
  std::vector<char> control(CMSG_SPACE(fds_size * sizeof(int)));
  msg.msg_control = &control[0];
  msg.msg_controllen = control.size();

  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  cmsg->cmsg_len = CMSG_LEN(fds_size * sizeof(int));
  cmsg->cmsg_level = SOL_SOCKET;
  cmsg->cmsg_type = SCM_RIGHTS;
  for (int i = 0; i < fds_size; i++) {
    memcpy(CMSG_DATA(cmsg) + i * sizeof(int), &fds[i], sizeof(int));
  }

  ASSERT_THAT(SendMsg(sock, &msg, buf, buf_size),
              IsPosixErrorOkAndHolds(buf_size));
}

void RecvSingleFD(int sock, int* fd, char buf[], int buf_size) {
  ASSERT_NO_FATAL_FAILURE(RecvFDs(sock, fd, 1, buf, buf_size, buf_size));
}

void RecvSingleFD(int sock, int* fd, char buf[], int buf_size,
                  int expected_size) {
  ASSERT_NO_FATAL_FAILURE(RecvFDs(sock, fd, 1, buf, buf_size, expected_size));
}

void RecvFDs(int sock, int fds[], int fds_size, char buf[], int buf_size) {
  ASSERT_NO_FATAL_FAILURE(
      RecvFDs(sock, fds, fds_size, buf, buf_size, buf_size));
}

void RecvFDs(int sock, int fds[], int fds_size, char buf[], int buf_size,
             int expected_size, bool peek) {
  struct msghdr msg = {};
  std::vector<char> control(CMSG_SPACE(fds_size * sizeof(int)));
  msg.msg_control = &control[0];
  msg.msg_controllen = control.size();

  struct iovec iov;
  iov.iov_base = buf;
  iov.iov_len = buf_size;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;

  int flags = 0;
  if (peek) {
    flags |= MSG_PEEK;
  }

  ASSERT_THAT(RetryEINTR(recvmsg)(sock, &msg, flags),
              SyscallSucceedsWithValue(expected_size));
  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  ASSERT_NE(cmsg, nullptr);
  ASSERT_EQ(cmsg->cmsg_len, CMSG_LEN(fds_size * sizeof(int)));
  ASSERT_EQ(cmsg->cmsg_level, SOL_SOCKET);
  ASSERT_EQ(cmsg->cmsg_type, SCM_RIGHTS);

  for (int i = 0; i < fds_size; i++) {
    memcpy(&fds[i], CMSG_DATA(cmsg) + i * sizeof(int), sizeof(int));
  }
}

void RecvFDs(int sock, int fds[], int fds_size, char buf[], int buf_size,
             int expected_size) {
  ASSERT_NO_FATAL_FAILURE(
      RecvFDs(sock, fds, fds_size, buf, buf_size, expected_size, false));
}

void PeekSingleFD(int sock, int* fd, char buf[], int buf_size) {
  ASSERT_NO_FATAL_FAILURE(RecvFDs(sock, fd, 1, buf, buf_size, buf_size, true));
}

void RecvNoCmsg(int sock, char buf[], int buf_size, int expected_size) {
  struct msghdr msg = {};
  char control[CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred))];
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct iovec iov;
  iov.iov_base = buf;
  iov.iov_len = buf_size;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;

  ASSERT_THAT(RetryEINTR(recvmsg)(sock, &msg, 0),
              SyscallSucceedsWithValue(expected_size));
  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  EXPECT_EQ(cmsg, nullptr);
}

void SendNullCmsg(int sock, char buf[], int buf_size) {
  struct msghdr msg = {};
  msg.msg_control = nullptr;
  msg.msg_controllen = 0;

  ASSERT_THAT(SendMsg(sock, &msg, buf, buf_size),
              IsPosixErrorOkAndHolds(buf_size));
}

void SendCreds(int sock, ucred creds, char buf[], int buf_size) {
  struct msghdr msg = {};

  char control[CMSG_SPACE(sizeof(struct ucred))];
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  cmsg->cmsg_level = SOL_SOCKET;
  cmsg->cmsg_type = SCM_CREDENTIALS;
  cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
  memcpy(CMSG_DATA(cmsg), &creds, sizeof(struct ucred));

  ASSERT_THAT(SendMsg(sock, &msg, buf, buf_size),
              IsPosixErrorOkAndHolds(buf_size));
}

void SendCredsAndFD(int sock, ucred creds, int fd, char buf[], int buf_size) {
  struct msghdr msg = {};

  char control[CMSG_SPACE(sizeof(struct ucred)) + CMSG_SPACE(sizeof(int))] = {};
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct cmsghdr* cmsg1 = CMSG_FIRSTHDR(&msg);
  cmsg1->cmsg_level = SOL_SOCKET;
  cmsg1->cmsg_type = SCM_CREDENTIALS;
  cmsg1->cmsg_len = CMSG_LEN(sizeof(struct ucred));
  memcpy(CMSG_DATA(cmsg1), &creds, sizeof(struct ucred));

  struct cmsghdr* cmsg2 = CMSG_NXTHDR(&msg, cmsg1);
  cmsg2->cmsg_level = SOL_SOCKET;
  cmsg2->cmsg_type = SCM_RIGHTS;
  cmsg2->cmsg_len = CMSG_LEN(sizeof(int));
  memcpy(CMSG_DATA(cmsg2), &fd, sizeof(int));

  ASSERT_THAT(SendMsg(sock, &msg, buf, buf_size),
              IsPosixErrorOkAndHolds(buf_size));
}

void RecvCreds(int sock, ucred* creds, char buf[], int buf_size) {
  ASSERT_NO_FATAL_FAILURE(RecvCreds(sock, creds, buf, buf_size, buf_size));
}

void RecvCreds(int sock, ucred* creds, char buf[], int buf_size,
               int expected_size) {
  struct msghdr msg = {};
  char control[CMSG_SPACE(sizeof(struct ucred))];
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct iovec iov;
  iov.iov_base = buf;
  iov.iov_len = buf_size;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;

  ASSERT_THAT(RetryEINTR(recvmsg)(sock, &msg, 0),
              SyscallSucceedsWithValue(expected_size));
  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  ASSERT_NE(cmsg, nullptr);
  ASSERT_EQ(cmsg->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
  ASSERT_EQ(cmsg->cmsg_level, SOL_SOCKET);
  ASSERT_EQ(cmsg->cmsg_type, SCM_CREDENTIALS);

  memcpy(creds, CMSG_DATA(cmsg), sizeof(struct ucred));
}

void RecvCredsAndFD(int sock, ucred* creds, int* fd, char buf[], int buf_size) {
  struct msghdr msg = {};
  char control[CMSG_SPACE(sizeof(struct ucred)) + CMSG_SPACE(sizeof(int))];
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct iovec iov;
  iov.iov_base = buf;
  iov.iov_len = buf_size;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;

  ASSERT_THAT(RetryEINTR(recvmsg)(sock, &msg, 0),
              SyscallSucceedsWithValue(buf_size));

  struct cmsghdr* cmsg1 = CMSG_FIRSTHDR(&msg);
  ASSERT_NE(cmsg1, nullptr);
  ASSERT_EQ(cmsg1->cmsg_len, CMSG_LEN(sizeof(struct ucred)));
  ASSERT_EQ(cmsg1->cmsg_level, SOL_SOCKET);
  ASSERT_EQ(cmsg1->cmsg_type, SCM_CREDENTIALS);
  memcpy(creds, CMSG_DATA(cmsg1), sizeof(struct ucred));

  struct cmsghdr* cmsg2 = CMSG_NXTHDR(&msg, cmsg1);
  ASSERT_NE(cmsg2, nullptr);
  ASSERT_EQ(cmsg2->cmsg_len, CMSG_LEN(sizeof(int)));
  ASSERT_EQ(cmsg2->cmsg_level, SOL_SOCKET);
  ASSERT_EQ(cmsg2->cmsg_type, SCM_RIGHTS);
  memcpy(fd, CMSG_DATA(cmsg2), sizeof(int));
}

void RecvSingleFDUnaligned(int sock, int* fd, char buf[], int buf_size) {
  struct msghdr msg = {};
  char control[CMSG_SPACE(sizeof(int)) - sizeof(int)];
  msg.msg_control = control;
  msg.msg_controllen = sizeof(control);

  struct iovec iov;
  iov.iov_base = buf;
  iov.iov_len = buf_size;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;

  ASSERT_THAT(RetryEINTR(recvmsg)(sock, &msg, 0),
              SyscallSucceedsWithValue(buf_size));

  struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
  ASSERT_NE(cmsg, nullptr);
  ASSERT_EQ(cmsg->cmsg_len, CMSG_LEN(sizeof(int)));
  ASSERT_EQ(cmsg->cmsg_level, SOL_SOCKET);
  ASSERT_EQ(cmsg->cmsg_type, SCM_RIGHTS);

  memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
}

void SetSoPassCred(int sock) {
  int one = 1;
  EXPECT_THAT(setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)),
              SyscallSucceeds());
}

void UnsetSoPassCred(int sock) {
  int zero = 0;
  EXPECT_THAT(setsockopt(sock, SOL_SOCKET, SO_PASSCRED, &zero, sizeof(zero)),
              SyscallSucceeds());
}

}  // namespace testing
}  // namespace gvisor