| // Copyright 2016 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <lib/fdio/fd.h> |
| #include <lib/fdio/fdio.h> |
| #include <lib/fdio/io.h> |
| #include <lib/zx/handle.h> |
| #include <lib/zx/socket.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <zircon/syscalls.h> |
| |
| #include <fbl/unique_fd.h> |
| #include <zxtest/zxtest.h> |
| |
| #include "predicates.h" |
| |
| TEST(HandleFDTest, Close) { |
| zx_handle_t h = ZX_HANDLE_INVALID; |
| ASSERT_OK(zx_event_create(0u, &h)); |
| ASSERT_NE(h, ZX_HANDLE_INVALID); |
| |
| // fdio_handle_fd() with shared_handle = true |
| int fd = fdio_handle_fd(h, ZX_USER_SIGNAL_0, ZX_USER_SIGNAL_1, true); |
| ASSERT_GE(fd, 0, "%s", strerror(errno)); |
| |
| close(fd); |
| |
| // close(fd) has not closed the wrapped handle |
| EXPECT_OK(zx_object_signal(h, 0, ZX_USER_SIGNAL_0)); |
| |
| // fdio_handle_fd() with shared_handle = false |
| fd = fdio_handle_fd(h, ZX_USER_SIGNAL_0, ZX_USER_SIGNAL_1, false); |
| ASSERT_GE(fd, 0, "%s", strerror(errno)); |
| |
| close(fd); |
| |
| // close(fd) has closed the wrapped handle |
| EXPECT_STATUS(zx_object_signal(h, 0, ZX_USER_SIGNAL_0), ZX_ERR_BAD_HANDLE); |
| } |
| |
| class HandleFD : public zxtest::Test { |
| protected: |
| void SetUp() override { |
| int fds[2]; |
| ASSERT_SUCCESS(pipe(fds)); |
| |
| for (size_t i = 0; i < fds_.size(); ++i) { |
| fds_[i].reset(fds[i]); |
| } |
| |
| int flags = fcntl(fds_[0].get(), F_GETFL); |
| ASSERT_GE(flags, 0, "%s", strerror(errno)); |
| ASSERT_SUCCESS(fcntl(fds_[0].get(), F_SETFL, flags | O_NONBLOCK)); |
| } |
| |
| const std::array<fbl::unique_fd, 2>& fds() { return fds_; } |
| std::array<fbl::unique_fd, 2>& mutable_fds() { return fds_; } |
| |
| private: |
| std::array<fbl::unique_fd, 2> fds_; |
| }; |
| |
| TEST_F(HandleFD, Pipe) { |
| for (const auto& fd : fds()) { |
| struct stat st; |
| ASSERT_SUCCESS(fstat(fd.get(), &st)); |
| ASSERT_EQ(st.st_mode & S_IFMT, unsigned(S_IFIFO)); |
| } |
| |
| constexpr char message[] = "hello"; |
| ASSERT_EQ(write(fds()[1].get(), message, sizeof(message)), ssize_t(sizeof(message)), "%s", |
| strerror(errno)); |
| |
| int available; |
| ASSERT_SUCCESS(ioctl(fds()[0].get(), FIONREAD, &available)); |
| EXPECT_EQ(available, ssize_t(sizeof(message))); |
| |
| char buffer[sizeof(message) + 1]; |
| ASSERT_EQ(read(fds()[0].get(), buffer, sizeof(buffer)), ssize_t(sizeof(message)), "%s", |
| strerror(errno)); |
| buffer[sizeof(message)] = 0; |
| |
| EXPECT_STREQ(buffer, message); |
| } |
| |
| TEST_F(HandleFD, TransferFD) { |
| constexpr char message[] = "hello"; |
| ASSERT_EQ(write(fds()[1].get(), message, sizeof(message)), ssize_t(sizeof(message)), "%s", |
| strerror(errno)); |
| |
| // fd --> handle |
| zx::handle handle; |
| ASSERT_OK(fdio_fd_transfer(mutable_fds()[0].release(), handle.reset_and_get_address())); |
| |
| // handle --> fd |
| ASSERT_OK(fdio_fd_create(handle.release(), mutable_fds()[0].reset_and_get_address())); |
| |
| // Read message |
| char buffer[sizeof(message) + 1]; |
| ASSERT_EQ(read(fds()[0].get(), buffer, sizeof(buffer)), ssize_t(sizeof(message)), "%s", |
| strerror(errno)); |
| buffer[sizeof(message)] = 0; |
| |
| EXPECT_STREQ(buffer, message); |
| } |
| |
| TEST(HandleFDTest, TransferDevice) { |
| fbl::unique_fd fd; |
| ASSERT_TRUE(fd = fbl::unique_fd(open("/dev/zero", O_RDONLY)), "%s", strerror(errno)); |
| |
| // fd --> handle |
| zx::handle handle; |
| ASSERT_OK(fdio_fd_transfer(fd.release(), handle.reset_and_get_address())); |
| |
| // handle --> fd |
| ASSERT_OK(fdio_fd_create(handle.release(), fd.reset_and_get_address())); |
| |
| ASSERT_SUCCESS(close(fd.release())); |
| } |
| |
| TEST(HandleFDTest, CreateFDFromConnectedSocket) { |
| zx::socket s1, s2; |
| ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &s1, &s2)); |
| |
| fbl::unique_fd fd; |
| ASSERT_OK(fdio_fd_create(s1.release(), fd.reset_and_get_address())); |
| |
| constexpr char message[] = "hello"; |
| size_t actual; |
| ASSERT_OK(s2.write(0, message, sizeof(message), &actual)); |
| ASSERT_EQ(actual, sizeof(message)); |
| |
| char buffer[sizeof(message) + 1]; |
| ASSERT_EQ(read(fd.get(), buffer, sizeof(buffer)), ssize_t(sizeof(message)), "%s", |
| strerror(errno)); |
| buffer[actual] = 0; |
| EXPECT_STREQ(buffer, message); |
| |
| // Set O_NONBLOCK |
| int flags = fcntl(fd.get(), F_GETFL); |
| ASSERT_GE(flags, 0, "%s", strerror(errno)); |
| ASSERT_SUCCESS(fcntl(fd.get(), F_SETFL, flags | O_NONBLOCK)); |
| ASSERT_EQ(read(fd.get(), buffer, sizeof(buffer)), -1); |
| ASSERT_ERRNO(EAGAIN); |
| } |
| |
| TEST(HandleFDTest, BindToFDInvalid) { |
| { |
| fdio_t* fdio = fdio_null_create(); |
| EXPECT_TRUE(fdio); |
| |
| // When binding and not providing a specific |fd|, the |
| // |starting_fd| must be nonnegative. |
| EXPECT_LT(fdio_bind_to_fd(fdio, -1, -1), 0); |
| EXPECT_ERRNO(EINVAL); |
| } |
| |
| { |
| fdio_t* fdio = fdio_null_create(); |
| EXPECT_TRUE(fdio); |
| |
| // Starting with a huge |starting_fd| will fail since the table |
| // does not hold so many. |
| EXPECT_LT(fdio_bind_to_fd(fdio, -1, INT_MAX), 0); |
| EXPECT_ERRNO(EMFILE); |
| } |
| } |