// Copyright 2018 Google LLC
//
// 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 <sched.h>
#include <sys/utsname.h>
#include <unistd.h>

#include "gtest/gtest.h"
#include "absl/strings/string_view.h"
#include "test/util/capability_util.h"
#include "test/util/test_util.h"
#include "test/util/thread_util.h"

namespace gvisor {
namespace testing {

namespace {

TEST(UnameTest, Sanity) {
  struct utsname buf;
  ASSERT_THAT(uname(&buf), SyscallSucceeds());
  EXPECT_NE(strlen(buf.release), 0);
  EXPECT_NE(strlen(buf.version), 0);
  EXPECT_NE(strlen(buf.machine), 0);
  EXPECT_NE(strlen(buf.sysname), 0);
  EXPECT_NE(strlen(buf.nodename), 0);
  EXPECT_NE(strlen(buf.domainname), 0);
}

TEST(UnameTest, SetNames) {
  SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));

  constexpr char kHostname[] = "wubbalubba";
  ASSERT_THAT(sethostname(kHostname, sizeof(kHostname)), SyscallSucceeds());

  constexpr char kDomainname[] = "dubdub.com";
  ASSERT_THAT(setdomainname(kDomainname, sizeof(kDomainname)),
              SyscallSucceeds());

  struct utsname buf;
  EXPECT_THAT(uname(&buf), SyscallSucceeds());
  EXPECT_EQ(absl::string_view(buf.nodename), kHostname);
  EXPECT_EQ(absl::string_view(buf.domainname), kDomainname);

  // These should just be glibc wrappers that also call uname(2).
  char hostname[65];
  EXPECT_THAT(gethostname(hostname, sizeof(hostname)), SyscallSucceeds());
  EXPECT_EQ(absl::string_view(hostname), kHostname);

  char domainname[65];
  EXPECT_THAT(getdomainname(domainname, sizeof(domainname)), SyscallSucceeds());
  EXPECT_EQ(absl::string_view(domainname), kDomainname);
}

TEST(UnameTest, UnprivilegedSetNames) {
  if (ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN))) {
    EXPECT_NO_ERRNO(SetCapability(CAP_SYS_ADMIN, false));
  }

  EXPECT_THAT(sethostname("", 0), SyscallFailsWithErrno(EPERM));
  EXPECT_THAT(setdomainname("", 0), SyscallFailsWithErrno(EPERM));
}

TEST(UnameTest, UnshareUTS) {
  SKIP_IF(!ASSERT_NO_ERRNO_AND_VALUE(HaveCapability(CAP_SYS_ADMIN)));

  struct utsname init;
  ASSERT_THAT(uname(&init), SyscallSucceeds());

  ScopedThread([&]() {
    EXPECT_THAT(unshare(CLONE_NEWUTS), SyscallSucceeds());

    constexpr char kHostname[] = "wubbalubba";
    EXPECT_THAT(sethostname(kHostname, sizeof(kHostname)), SyscallSucceeds());

    char hostname[65];
    EXPECT_THAT(gethostname(hostname, sizeof(hostname)), SyscallSucceeds());
  });

  struct utsname after;
  EXPECT_THAT(uname(&after), SyscallSucceeds());
  EXPECT_EQ(absl::string_view(after.nodename), init.nodename);
}

}  // namespace

}  // namespace testing
}  // namespace gvisor