Method send

src/posix/poll_socket.cpp:185–235

Future<size_t> PollSocketImpl::send(const char* data, size_t size)
{
  CHECK(size > 0); // TODO(benh): Just return 0 if `size` is 0?

  // Need to hold a copy of `this` so that the underlying socket
  // doesn't end up getting reused before we return.
  auto self = shared(this);

  // TODO(benh): Reuse `io::write`? Or is `net::send` and
  // `MSG_NOSIGNAL` critical here?
  return loop(
      None(),
      [self, data, size]() -> Future<Option<size_t>> {
        while (true) {
          ssize_t length = net::send(self->get(), data, size, MSG_NOSIGNAL);

          if (length < 0) {
#ifdef __WINDOWS__
            int error = WSAGetLastError();
#else
            int error = errno;
#endif // __WINDOWS__

            if (net::is_restartable_error(error)) {
              // Interrupted, try again now.
              continue;
            } else if (!net::is_retryable_error(error)) {
              // TODO(benh): Confirm that `os::strerror` does the
              // right thing for `error` on Windows.
              VLOG(1) << "Socket error while sending: " << os::strerror(error);
              return Failure(os::strerror(error));
            }

            return None();
          }

          return length;
        }
      },
      [self](const Option<size_t>& length) -> Future<ControlFlow<size_t>> {
        // Retry after we've polled if we don't yet have a result.
        if (length.isNone()) {
          return io::poll(self->get(), io::WRITE)
            .then([](short event) -> ControlFlow<size_t> {
              CHECK_EQ(io::WRITE, event);
              return Continue();
            });
        }
        return Break(length.get());
      });
}


Future<size_t> PollSocketImpl::sendfile(int_fd fd, off_t offset, size_t size)