Function handle_io

src/windows/libwinio.cpp:154–225

static void handle_io(OVERLAPPED* overlapped_, DWORD bytes_transferred)
{
  // Overlapped objects to passed to this function should have been contained
  // inside a `IOOverlappedBase`. So, we can use the `CONTAINING_RECORD` macro
  // to get the pointer to the `IOOverlappedBase` struct from the `OVERLAPPED`
  // pointer.
  IOOverlappedBase* overlapped_base =
    CONTAINING_RECORD(overlapped_, IOOverlappedBase, overlapped);

  // Get the Win32 error code of the overlapped operation. The status code
  // is actually in overlapped->overlapped->Internal, but it's the NT
  // status code instead of the Win32 error.
  DWORD error = ERROR_SUCCESS;
  DWORD bytes;
  const BOOL success = ::GetOverlappedResult(
      overlapped_base->handle, &overlapped_base->overlapped, &bytes, FALSE);

  if (!success) {
    error = ::GetLastError();
  } else {
    // If the IO succeeded, these should be the same for sure.
    CHECK_EQ(bytes, bytes_transferred);
  }

  switch (overlapped_base->type) {
    case IOType::READ:
    case IOType::RECV: {
      IOOverlappedReadWrite* io_read =
        CONTAINING_RECORD(overlapped_base, IOOverlappedReadWrite, base);

      std::unique_ptr<Promise<size_t>> promise(io_read->promise);

      // For reads, we need to make sure we ignore the EOF errors.
      if (error == ERROR_BROKEN_PIPE || error == ERROR_HANDLE_EOF) {
        set_io_promise(promise.get(), static_cast<size_t>(0), ERROR_SUCCESS);
      } else {
        set_io_promise(
            promise.get(), static_cast<size_t>(bytes_transferred), error);
      }
      return;
    }
    case IOType::WRITE:
    case IOType::SEND:
    case IOType::SENDFILE: {
      IOOverlappedReadWrite* io_write =
        CONTAINING_RECORD(overlapped_base, IOOverlappedReadWrite, base);

      std::unique_ptr<Promise<size_t>> promise(io_write->promise);
      set_io_promise(
          promise.get(), static_cast<size_t>(bytes_transferred), error);
      return;
    }
    case IOType::CONNECT: {
      IOOverlappedConnect* io_connect =
        CONTAINING_RECORD(overlapped_base, IOOverlappedConnect, base);

      std::unique_ptr<Promise<Nothing>> promise(io_connect->promise);
      set_io_promise(promise.get(), Nothing(), error);