429 lines
16 KiB
C++
429 lines
16 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 <fcntl.h>
|
|
#include <sys/sendfile.h>
|
|
#include <unistd.h>
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "gtest/gtest.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "test/util/file_descriptor.h"
|
|
#include "test/util/temp_path.h"
|
|
#include "test/util/test_util.h"
|
|
|
|
namespace gvisor {
|
|
namespace testing {
|
|
|
|
namespace {
|
|
|
|
TEST(SendFileTest, SendZeroBytes) {
|
|
// Create temp files.
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, 0),
|
|
SyscallSucceedsWithValue(0));
|
|
}
|
|
|
|
TEST(SendFileTest, InvalidOffset) {
|
|
// Create temp files.
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
off_t offset = -1;
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), &offset, 0),
|
|
SyscallFailsWithErrno(EINVAL));
|
|
}
|
|
|
|
TEST(SendFileTest, SendTrivially) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "To be, or not to be, that is the question:";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(bytes_sent = sendfile(outf.get(), inf.get(), nullptr, kDataSize),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
|
|
// Close outf to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
EXPECT_EQ(kData, absl::string_view(actual, bytes_sent));
|
|
}
|
|
|
|
TEST(SendFileTest, SendTriviallyWithBothFilesReadWrite) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "Whether 'tis nobler in the mind to suffer";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as readwrite.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDWR));
|
|
|
|
// Open the output file as readwrite.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDWR));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(bytes_sent = sendfile(outf.get(), inf.get(), nullptr, kDataSize),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
|
|
// Close outf to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
EXPECT_EQ(kData, absl::string_view(actual, bytes_sent));
|
|
}
|
|
|
|
TEST(SendFileTest, SendAndUpdateFileOffset) {
|
|
// Create temp files.
|
|
// Test input std::string length must be > 2 AND even.
|
|
constexpr char kData[] = "The slings and arrows of outrageous fortune,";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
constexpr int kHalfDataSize = kDataSize / 2;
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(
|
|
bytes_sent = sendfile(outf.get(), inf.get(), nullptr, kHalfDataSize),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
|
|
// Close outf to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kHalfDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
EXPECT_EQ(absl::string_view(kData, kHalfDataSize),
|
|
absl::string_view(actual, bytes_sent));
|
|
|
|
// Verify that the input file offset has been updated
|
|
ASSERT_THAT(read(inf.get(), &actual, kDataSize - bytes_sent),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
EXPECT_EQ(
|
|
absl::string_view(kData + kDataSize - bytes_sent, kDataSize - bytes_sent),
|
|
absl::string_view(actual, kHalfDataSize));
|
|
}
|
|
|
|
TEST(SendFileTest, SendAndUpdateFileOffsetFromNonzeroStartingPoint) {
|
|
// Create temp files.
|
|
// Test input std::string length must be > 2 AND divisible by 4.
|
|
constexpr char kData[] = "The slings and arrows of outrageous fortune,";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
constexpr int kHalfDataSize = kDataSize / 2;
|
|
constexpr int kQuarterDataSize = kHalfDataSize / 2;
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Read a quarter of the data from the infile which should update the file
|
|
// offset, we don't actually care about the data so it goes into the garbage.
|
|
char garbage[kQuarterDataSize];
|
|
ASSERT_THAT(read(inf.get(), &garbage, kQuarterDataSize),
|
|
SyscallSucceedsWithValue(kQuarterDataSize));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(
|
|
bytes_sent = sendfile(outf.get(), inf.get(), nullptr, kHalfDataSize),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
|
|
// Close out_fd to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kHalfDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
EXPECT_EQ(absl::string_view(kData + kQuarterDataSize, kHalfDataSize),
|
|
absl::string_view(actual, bytes_sent));
|
|
|
|
// Verify that the input file offset has been updated
|
|
ASSERT_THAT(read(inf.get(), &actual, kQuarterDataSize),
|
|
SyscallSucceedsWithValue(kQuarterDataSize));
|
|
|
|
EXPECT_EQ(
|
|
absl::string_view(kData + kDataSize - kQuarterDataSize, kQuarterDataSize),
|
|
absl::string_view(actual, kQuarterDataSize));
|
|
}
|
|
|
|
TEST(SendFileTest, SendAndUpdateGivenOffset) {
|
|
// Create temp files.
|
|
// Test input std::string length must be >= 4 AND divisible by 4.
|
|
constexpr char kData[] = "Or to take Arms against a Sea of troubles,";
|
|
constexpr int kDataSize = sizeof(kData) + 1;
|
|
constexpr int kHalfDataSize = kDataSize / 2;
|
|
constexpr int kQuarterDataSize = kHalfDataSize / 2;
|
|
constexpr int kThreeFourthsDataSize = 3 * kDataSize / 4;
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Create offset for sending.
|
|
off_t offset = kQuarterDataSize;
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(
|
|
bytes_sent = sendfile(outf.get(), inf.get(), &offset, kHalfDataSize),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
|
|
// Close out_fd to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kHalfDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
EXPECT_EQ(absl::string_view(kData + kQuarterDataSize, kHalfDataSize),
|
|
absl::string_view(actual, bytes_sent));
|
|
|
|
// Verify that the input file offset has NOT been updated.
|
|
ASSERT_THAT(read(inf.get(), &actual, kHalfDataSize),
|
|
SyscallSucceedsWithValue(kHalfDataSize));
|
|
EXPECT_EQ(absl::string_view(kData, kHalfDataSize),
|
|
absl::string_view(actual, kHalfDataSize));
|
|
|
|
// Verify that the offset pointer has been updated.
|
|
EXPECT_EQ(offset, kThreeFourthsDataSize);
|
|
}
|
|
|
|
TEST(SendFileTest, DoNotSendfileIfOutfileIsAppendOnly) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "And by opposing end them: to die, to sleep";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as append only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_APPEND));
|
|
|
|
// Send data and verify that sendfile returns the correct errno.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, kDataSize),
|
|
SyscallFailsWithErrno(EBADF));
|
|
}
|
|
|
|
TEST(SendFileTest, DoNotSendfileIfOutfileIsNotWritable) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "No more; and by a sleep, to say we end";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as read only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct errno.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, kDataSize),
|
|
SyscallFailsWithErrno(EBADF));
|
|
}
|
|
|
|
TEST(SendFileTest, DoNotSendfileIfInfileIsNotReadable) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "the heart-ache, and the thousand natural shocks";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as write only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_WRONLY));
|
|
|
|
// Open the output file as write only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct errno.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, kDataSize),
|
|
SyscallFailsWithErrno(EBADF));
|
|
}
|
|
|
|
TEST(SendFileTest, DoNotSendANegativeNumberOfBytes) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "that Flesh is heir to? 'Tis a consummation";
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct errno.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, -1),
|
|
SyscallFailsWithErrno(EINVAL));
|
|
}
|
|
|
|
TEST(SendFileTest, SendTheCorrectNumberOfBytesEvenIfWeTryToSendTooManyBytes) {
|
|
// Create temp files.
|
|
constexpr char kData[] = "devoutly to be wished. To die, to sleep,";
|
|
constexpr int kDataSize = sizeof(kData) - 1;
|
|
|
|
const TempPath in_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
|
|
GetAbsoluteTestTmpdir(), kData, TempPath::kDefaultFileMode));
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
|
|
// Open the input file as read only.
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(in_file.path(), O_RDONLY));
|
|
|
|
// Open the output file as write only.
|
|
FileDescriptor outf;
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Send data and verify that sendfile returns the correct value.
|
|
int bytes_sent;
|
|
EXPECT_THAT(
|
|
bytes_sent = sendfile(outf.get(), inf.get(), nullptr, kDataSize + 100),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
|
|
// Close outf to avoid leak.
|
|
outf.reset();
|
|
|
|
// Open the output file as read only.
|
|
outf = ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_RDONLY));
|
|
|
|
// Verify that the output file has the correct data.
|
|
char actual[kDataSize];
|
|
ASSERT_THAT(read(outf.get(), &actual, bytes_sent),
|
|
SyscallSucceedsWithValue(kDataSize));
|
|
EXPECT_EQ(kData, absl::string_view(actual, bytes_sent));
|
|
}
|
|
|
|
TEST(SendFileTest, SendToNotARegularFile) {
|
|
// Make temp input directory and open as read only.
|
|
const TempPath dir = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
|
|
const FileDescriptor inf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(dir.path(), O_RDONLY));
|
|
|
|
// Make temp output file and open as write only.
|
|
const TempPath out_file = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFile());
|
|
const FileDescriptor outf =
|
|
ASSERT_NO_ERRNO_AND_VALUE(Open(out_file.path(), O_WRONLY));
|
|
|
|
// Receive an error since a directory is not a regular file.
|
|
EXPECT_THAT(sendfile(outf.get(), inf.get(), nullptr, 0),
|
|
SyscallFailsWithErrno(EINVAL));
|
|
}
|
|
} // namespace
|
|
|
|
} // namespace testing
|
|
} // namespace gvisor
|