Method accept

src/posix/poll_socket.cpp:53–113

Future<std::shared_ptr<SocketImpl>> PollSocketImpl::accept()
{
  // Need to hold a copy of `this` so that the underlying socket
  // doesn't end up getting reused before we return from the call to
  // `io::poll` and end up accepting a socket incorrectly.
  auto self = shared(this);

  return io::poll(get(), io::READ)
    .then([self]() -> Future<std::shared_ptr<SocketImpl>> {
      Try<int_fd> accepted = network::accept(self->get());
      if (accepted.isError()) {
        return Failure(accepted.error());
      }

      int_fd s = accepted.get();
      Try<Nothing> nonblock = os::nonblock(s);
      if (nonblock.isError()) {
        os::close(s);
        return Failure("Failed to accept, nonblock: " + nonblock.error());
      }

      Try<Nothing> cloexec = os::cloexec(s);
      if (cloexec.isError()) {
        os::close(s);
        return Failure("Failed to accept, cloexec: " + cloexec.error());
      }

      Try<Address> address = network::address(s);
      if (address.isError()) {
        os::close(s);
        return Failure("Failed to get address: " + address.error());
      }

      // Turn off Nagle (TCP_NODELAY) so pipelined requests don't wait.
      // NOTE: We cast to `char*` here because the function prototypes
      // on Windows use `char*` instead of `void*`.
      if (address->family() == Address::Family::INET4 ||
          address->family() == Address::Family::INET6) {
        int on = 1;
        if (::setsockopt(
                s,
                SOL_TCP,
                TCP_NODELAY,
                reinterpret_cast<const char*>(&on),
                sizeof(on)) < 0) {
          const string error = os::strerror(errno);
          os::close(s);
          return Failure(
              "Failed to turn off the Nagle algorithm: " + stringify(error));
        }
      }

      Try<std::shared_ptr<SocketImpl>> impl = create(s);
      if (impl.isError()) {
        os::close(s);
        return Failure("Failed to create socket: " + impl.error());
      }