100 lines
3.1 KiB
C++
100 lines
3.1 KiB
C++
// 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
|