constexpr int messageTypeContainsIP() {

  return IP_PKTINFO;

#endif

}

in_addr addressFromMessage(const cmsghdr& cmsg) {

  auto info = reinterpret_cast<const in_pktinfo*>(CMSG_DATA(&cmsg));

  return info->ipi_addr;

#endif

}

constexpr int messageTruncatedOption() {

  return MSG_TRUNC;

#endif

}

IoSocketHandleImpl::~IoSocketHandleImpl() {

  if (SOCKET_VALID(fd_)) {

    IoSocketHandleImpl::close();

  }

}

Api::IoCallUint64Result IoSocketHandleImpl::close() {

  if (file_event_) {

    file_event_.reset();

  }

  ASSERT(SOCKET_VALID(fd_));

  const int rc = Api::OsSysCallsSingleton::get().close(fd_).return_value_;

  SET_SOCKET_INVALID(fd_);

  return {static_cast<unsigned long>(rc), Api::IoError::none()};

}

                                                  uint64_t num_slice) {

  absl::FixedArray<iovec> iov(num_slice);

  uint64_t num_slices_to_read = 0;

  uint64_t num_bytes_to_read = 0;

  for (; num_slices_to_read < num_slice && num_bytes_to_read < max_length; num_slices_to_read++) {

    iov[num_slices_to_read].iov_base = slices[num_slices_to_read].mem_;

    const size_t slice_length = std::min(slices[num_slices_to_read].len_,

                                         static_cast<size_t>(max_length - num_bytes_to_read));

    iov[num_slices_to_read].iov_len = slice_length;

    num_bytes_to_read += slice_length;

  }

  ASSERT(num_bytes_to_read <= max_length);

  if (num_slices_to_read == 1) {

    return sysCallResultToIoCallResult(

        Api::OsSysCallsSingleton::get().recv(fd_, iov[0].iov_base, iov[0].iov_len, 0));

  }

  auto result = sysCallResultToIoCallResult(Api::OsSysCallsSingleton::get().readv(

      fd_, iov.begin(), static_cast<int>(num_slices_to_read)));

  return result;

}

                                                 absl::optional<uint64_t> max_length_opt) {

  const uint64_t max_length = max_length_opt.value_or(UINT64_MAX);

  if (max_length == 0) {

    return Api::ioCallUint64ResultNoError();

  }

  Buffer::Reservation reservation = buffer.reserveForRead();

  Api::IoCallUint64Result result = readv(std::min(reservation.length(), max_length),

                                         reservation.slices(), reservation.numSlices());

  uint64_t bytes_to_commit = result.ok() ? result.return_value_ : 0;

  ASSERT(bytes_to_commit <= max_length);

  reservation.commit(bytes_to_commit);

  return result;

}

                                                   uint64_t num_slice) {

  absl::FixedArray<iovec> iov(num_slice);

  uint64_t num_slices_to_write = 0;

  for (uint64_t i = 0; i < num_slice; i++) {

    if (slices[i].mem_ != nullptr && slices[i].len_ != 0) {

      iov[num_slices_to_write].iov_base = slices[i].mem_;

      iov[num_slices_to_write].iov_len = slices[i].len_;

      num_slices_to_write++;

    }

  }

  if (num_slices_to_write == 0) {

    return Api::ioCallUint64ResultNoError();

  }

  if (num_slices_to_write == 1) {

    return sysCallResultToIoCallResult(

        Api::OsSysCallsSingleton::get().send(fd_, iov[0].iov_base, iov[0].iov_len, 0));

  }

  auto result = sysCallResultToIoCallResult(

      Api::OsSysCallsSingleton::get().writev(fd_, iov.begin(), num_slices_to_write));

  return result;

}

Api::IoCallUint64Result IoSocketHandleImpl::write(Buffer::Instance& buffer) {

  constexpr uint64_t MaxSlices = 16;

  Buffer::RawSliceVector slices = buffer.getRawSlices(MaxSlices);

  Api::IoCallUint64Result result = writev(slices.begin(), slices.size());

  if (result.ok() && result.return_value_ > 0) {

    buffer.drain(static_cast<uint64_t>(result.return_value_));

  }

  return result;

}

                                                    const Address::Instance& peer_address) {

  const auto* address_base = dynamic_cast<const Address::InstanceBase*>(&peer_address);

  sockaddr* sock_addr = const_cast<sockaddr*>(address_base->sockAddr());

  if (sock_addr == nullptr) {

    return IoSocketError::ioResultSocketInvalidAddress();

  }

  absl::FixedArray<iovec> iov(num_slice);

  uint64_t num_slices_to_write = 0;

  for (uint64_t i = 0; i < num_slice; i++) {

    if (slices[i].mem_ != nullptr && slices[i].len_ != 0) {

      iov[num_slices_to_write].iov_base = slices[i].mem_;

      iov[num_slices_to_write].iov_len = slices[i].len_;

      num_slices_to_write++;

    }

  }

  if (num_slices_to_write == 0) {

  msghdr message;

  message.msg_name = reinterpret_cast<void*>(sock_addr);

  message.msg_namelen = address_base->sockAddrLen();

  message.msg_iov = iov.begin();

  message.msg_iovlen = num_slices_to_write;

  message.msg_flags = 0;

  auto& os_syscalls = Api::OsSysCallsSingleton::get();

  if (self_ip == nullptr) {

    message.msg_control = nullptr;

    message.msg_controllen = 0;

    const Api::SysCallSizeResult result = os_syscalls.sendmsg(fd_, &message, flags);

    return sysCallResultToIoCallResult(result);

  } else {

    const size_t space_v6 = CMSG_SPACE(sizeof(in6_pktinfo));

    const size_t space_v4 = CMSG_SPACE(sizeof(in_pktinfo));

    const size_t cmsg_space = (self_ip->version() == Address::IpVersion::v4) ? space_v4 : space_v6;

    absl::FixedArray<char> cbuf(cmsg_space);

    memset(cbuf.begin(), 0, cmsg_space);

    message.msg_control = cbuf.begin();

    message.msg_controllen = cmsg_space;

    cmsghdr* const cmsg = CMSG_FIRSTHDR(&message);

    RELEASE_ASSERT(cmsg != nullptr, fmt::format("cbuf with size {} is not enough, cmsghdr size {}",

                                                sizeof(cbuf), sizeof(cmsghdr)));

    if (self_ip->version() == Address::IpVersion::v4) {

      cmsg->cmsg_level = IPPROTO_IP;

#ifndef IP_SENDSRCADDR

      cmsg->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));

      cmsg->cmsg_type = IP_PKTINFO;

      auto pktinfo = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));

      pktinfo->ipi_ifindex = 0;

      pktinfo->ipi_spec_dst.s_addr = self_ip->ipv4()->address();

#endif

    } else if (self_ip->version() == Address::IpVersion::v6) {

      cmsg->cmsg_len = CMSG_LEN(sizeof(in6_pktinfo));

      cmsg->cmsg_level = IPPROTO_IPV6;

      cmsg->cmsg_type = IPV6_PKTINFO;

      auto pktinfo = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));

      pktinfo->ipi6_ifindex = 0;

      *(reinterpret_cast<absl::uint128*>(pktinfo->ipi6_addr.s6_addr)) = self_ip->ipv6()->address();

    }

    const Api::SysCallSizeResult result = os_syscalls.sendmsg(fd_, &message, flags);

    if (result.return_value_ < 0 && result.errno_ == SOCKET_ERROR_INVAL) {

      ENVOY_LOG(error, fmt::format("EINVAL error. Socket is open: {}, IPv{}.", isOpen(),

                                   self_ip->version() == Address::IpVersion::v6 ? 6 : 4));

    }

    return sysCallResultToIoCallResult(result);

  }

}

IoSocketHandleImpl::getOrCreateEnvoyAddressInstance(sockaddr_storage ss, socklen_t ss_len) {

  if (!recent_received_addresses_) {

    return Address::addressFromSockAddrOrDie(ss, ss_len, fd_, socket_v6only_);

  }

  quic::QuicSocketAddress quic_address(ss);

  auto it = std::find_if(

      recent_received_addresses_->begin(), recent_received_addresses_->end(),

      [&quic_address](const QuicEnvoyAddressPair& pair) { return pair.first == quic_address; });

  if (it != recent_received_addresses_->end()) {

    Address::InstanceConstSharedPtr cached_addr = it->second;

    std::rotate(it, it + 1, recent_received_addresses_->end());

    return cached_addr;

  }

  Address::InstanceConstSharedPtr new_address =

      Address::addressFromSockAddrOrDie(ss, ss_len, fd_, socket_v6only_);

  recent_received_addresses_->push_back(QuicEnvoyAddressPair(quic_address, new_address));

  if (recent_received_addresses_->size() > address_cache_max_capacity_) {

    recent_received_addresses_->erase(recent_received_addresses_->begin());

  }

  return new_address;

}

IoSocketHandleImpl::maybeGetDstAddressFromHeader(const cmsghdr& cmsg, uint32_t self_port) {

  if (cmsg.cmsg_type == IPV6_PKTINFO) {

  if (cmsg.cmsg_type == messageTypeContainsIP()) {

    sockaddr_storage ss;

    auto ipv4_addr = reinterpret_cast<sockaddr_in*>(&ss);

    memset(ipv4_addr, 0, sizeof(sockaddr_in));

    ipv4_addr->sin_family = AF_INET;

    ipv4_addr->sin_addr = addressFromMessage(cmsg);

    ipv4_addr->sin_port = htons(self_port);

    return getOrCreateEnvoyAddressInstance(ss, sizeof(sockaddr_in));

  }

  return nullptr;

}

absl::optional<uint32_t> maybeGetPacketsDroppedFromHeader([[maybe_unused]] const cmsghdr& cmsg) {

#ifdef SO_RXQ_OVFL

  if (cmsg.cmsg_type == SO_RXQ_OVFL) {

    return *reinterpret_cast<const uint32_t*>(CMSG_DATA(&cmsg));

  }

#endif

  return absl::nullopt;

}

template <typename T> T getUnsignedIntFromHeader(const cmsghdr& cmsg) {

  static_assert(std::is_unsigned_v<T>, "return type must be unsigned integral");

  T value;

  safeMemcpyUnsafeSrc(&value, CMSG_DATA(&cmsg));

  return value;

}

template <typename T> absl::optional<T> maybeGetUnsignedIntFromHeader(const cmsghdr& cmsg) {

  static_assert(std::is_unsigned_v<T>, "return type must be unsigned integral");

  switch (cmsg.cmsg_len) {

  case CMSG_LEN(sizeof(uint8_t)):

    return static_cast<T>(getUnsignedIntFromHeader<uint8_t>(cmsg));

  case CMSG_LEN(sizeof(uint16_t)):

    return static_cast<T>(getUnsignedIntFromHeader<uint16_t>(cmsg));

  case CMSG_LEN(sizeof(uint32_t)):

    return static_cast<T>(getUnsignedIntFromHeader<uint32_t>(cmsg));

  }

}

absl::optional<uint8_t> maybeGetTosFromHeader(const cmsghdr& cmsg) {

  if (

      (cmsg.cmsg_level == IPPROTO_IP && cmsg.cmsg_type == IP_TOS) ||

#endif // __APPLE__

      (cmsg.cmsg_level == IPPROTO_IPV6 && cmsg.cmsg_type == IPV6_TCLASS)) {

    return maybeGetUnsignedIntFromHeader<uint8_t>(cmsg);

  }

  return absl::nullopt;

}

                                                    RecvMsgOutput& output) {

  ASSERT(!output.msg_.empty());

  size_t cmsg_space = cmsg_space_ + save_cmsg_config.expected_size;

  absl::FixedArray<char> cbuf(cmsg_space);

  memset(cbuf.begin(), 0, cmsg_space);

  absl::FixedArray<iovec> iov(num_slice);

  uint64_t num_slices_for_read = 0;

  for (uint64_t i = 0; i < num_slice; i++) {

    if (slices[i].mem_ != nullptr && slices[i].len_ != 0) {

      iov[num_slices_for_read].iov_base = slices[i].mem_;

      iov[num_slices_for_read].iov_len = slices[i].len_;

      ++num_slices_for_read;

    }

  }

  if (num_slices_for_read == 0) {

  sockaddr_storage peer_addr;

  msghdr hdr;

  hdr.msg_name = &peer_addr;

  hdr.msg_namelen = sizeof(sockaddr_storage);

  hdr.msg_iov = iov.begin();

  hdr.msg_iovlen = num_slices_for_read;

  hdr.msg_flags = 0;

  hdr.msg_control = cbuf.begin();

  hdr.msg_controllen = cmsg_space_;

  Api::SysCallSizeResult result =

      Api::OsSysCallsSingleton::get().recvmsg(fd_, &hdr, messageTruncatedOption());

  if (result.return_value_ < 0) {

    return sysCallResultToIoCallResult(result);

  }

  if ((hdr.msg_flags & MSG_TRUNC) != 0) {

  RELEASE_ASSERT((hdr.msg_flags & MSG_CTRUNC) == 0,

                 fmt::format("Incorrectly set control message length: {}", hdr.msg_controllen));

  RELEASE_ASSERT(hdr.msg_namelen > 0,

                 fmt::format("Unable to get remote address from recvmsg() for fd: {}", fd_));

  output.msg_[0].peer_address_ = getOrCreateEnvoyAddressInstance(peer_addr, hdr.msg_namelen);

  output.msg_[0].gso_size_ = 0;

  if (hdr.msg_controllen > 0) {

    for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr;

         cmsg = CMSG_NXTHDR(&hdr, cmsg)) {

      if (save_cmsg_config.hasConfig() &&

          cmsg->cmsg_type == static_cast<int>(save_cmsg_config.type.value()) &&

          cmsg->cmsg_level == static_cast<int>(save_cmsg_config.level.value())) {

      if (output.msg_[0].local_address_ == nullptr) {

        Address::InstanceConstSharedPtr addr = maybeGetDstAddressFromHeader(*cmsg, self_port);

        if (addr != nullptr) {

          output.msg_[0].local_address_ = std::move(addr);

          continue;

        }

      }

      if (output.dropped_packets_ != nullptr) {

        absl::optional<uint32_t> maybe_dropped = maybeGetPacketsDroppedFromHeader(*cmsg);

        if (maybe_dropped) {

          *output.dropped_packets_ = *maybe_dropped;

          continue;

        }

      }

#ifdef UDP_GRO

      if (cmsg->cmsg_level == SOL_UDP && cmsg->cmsg_type == UDP_GRO) {

        absl::optional<uint16_t> maybe_gso = maybeGetUnsignedIntFromHeader<uint16_t>(*cmsg);

        if (maybe_gso) {

          output.msg_[0].gso_size_ = *maybe_gso;

        }

      }

#endif

      absl::optional<uint8_t> maybe_tos = maybeGetTosFromHeader(*cmsg);

      if (maybe_tos) {

        output.msg_[0].tos_ = *maybe_tos;

      }

    }

  }

  return sysCallResultToIoCallResult(result);

}

                                                     RecvMsgOutput& output) {

  ASSERT(output.msg_.size() == slices.size());

  if (slices.empty()) {

  const uint32_t num_packets_per_mmsg_call = slices.size();

  absl::FixedArray<mmsghdr> mmsg_hdr(num_packets_per_mmsg_call);

  absl::FixedArray<absl::FixedArray<struct iovec>> iovs(

      num_packets_per_mmsg_call, absl::FixedArray<struct iovec>(slices[0].size()));

  absl::FixedArray<sockaddr_storage> raw_addresses(num_packets_per_mmsg_call);

  size_t cmsg_space = cmsg_space_ + save_cmsg_config.expected_size;

  absl::FixedArray<absl::FixedArray<char>> cbufs(num_packets_per_mmsg_call,

                                                 absl::FixedArray<char>(cmsg_space));

  for (uint32_t i = 0; i < num_packets_per_mmsg_call; ++i) {

    memset(&raw_addresses[i], 0, sizeof(sockaddr_storage));

    memset(cbufs[i].data(), 0, cbufs[i].size());

    mmsg_hdr[i].msg_len = 0;

    msghdr* hdr = &mmsg_hdr[i].msg_hdr;

    hdr->msg_name = &raw_addresses[i];

    hdr->msg_namelen = sizeof(sockaddr_storage);

    ASSERT(!slices[i].empty());

    for (size_t j = 0; j < slices[i].size(); ++j) {

      iovs[i][j].iov_base = slices[i][j].mem_;

      iovs[i][j].iov_len = slices[i][j].len_;

    }

    hdr->msg_iov = iovs[i].data();

    hdr->msg_iovlen = slices[i].size();

    hdr->msg_control = cbufs[i].data();

    hdr->msg_controllen = cbufs[i].size();

  }

  const Api::SysCallIntResult result =

      Api::OsSysCallsSingleton::get().recvmmsg(fd_, mmsg_hdr.data(), num_packets_per_mmsg_call,

                                               messageTruncatedOption() | MSG_WAITFORONE, nullptr);

  if (result.return_value_ <= 0) {

    return sysCallResultToIoCallResult(result);

  }

  int num_packets_read = result.return_value_;

  for (int i = 0; i < num_packets_read; ++i) {

    msghdr& hdr = mmsg_hdr[i].msg_hdr;

    if ((hdr.msg_flags & MSG_TRUNC) != 0) {

      ENVOY_LOG_MISC(debug, "Dropping truncated UDP packet with size: {}.", mmsg_hdr[i].msg_len);

      (*output.dropped_packets_)++;

      output.msg_[i].truncated_and_dropped_ = true;

      continue;

    }

    RELEASE_ASSERT((hdr.msg_flags & MSG_CTRUNC) == 0,

                   fmt::format("Incorrectly set control message length: {}", hdr.msg_controllen));

    RELEASE_ASSERT(hdr.msg_namelen > 0,

                   fmt::format("Unable to get remote address from recvmmsg() for fd: {}", fd_));

    output.msg_[i].msg_len_ = mmsg_hdr[i].msg_len;

    output.msg_[i].peer_address_ =

        getOrCreateEnvoyAddressInstance(raw_addresses[i], hdr.msg_namelen);

    if (hdr.msg_controllen > 0) {

      struct cmsghdr* cmsg;

      for (cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr; cmsg = CMSG_NXTHDR(&hdr, cmsg)) {

        if (save_cmsg_config.hasConfig() &&

            cmsg->cmsg_type == static_cast<int>(save_cmsg_config.type.value()) &&

            cmsg->cmsg_level == static_cast<int>(save_cmsg_config.level.value())) {

          Buffer::OwnedImpl cmsg_slice{CMSG_DATA(cmsg), cmsg->cmsg_len};

          output.msg_[i].saved_cmsg_ = std::move(cmsg_slice);

        }

        Address::InstanceConstSharedPtr addr = maybeGetDstAddressFromHeader(*cmsg, self_port);

        absl::optional<uint8_t> maybe_tos = maybeGetTosFromHeader(*cmsg);

        if (maybe_tos) {

          output.msg_[0].tos_ = *maybe_tos;

          continue;

        }

        if (addr != nullptr) {

          output.msg_[i].local_address_ = std::move(addr);

          continue;

        }

      }

    }

  }

  if (output.dropped_packets_ != nullptr) {

    msghdr& hdr = mmsg_hdr[0].msg_hdr;

    if (hdr.msg_controllen > 0) {

      struct cmsghdr* cmsg;

      for (cmsg = CMSG_FIRSTHDR(&hdr); cmsg != nullptr; cmsg = CMSG_NXTHDR(&hdr, cmsg)) {

        absl::optional<uint32_t> maybe_dropped = maybeGetPacketsDroppedFromHeader(*cmsg);

        if (maybe_dropped) {

          *output.dropped_packets_ = *maybe_dropped;

        }

      }

    }

  }

  return sysCallResultToIoCallResult(result);

}

Api::IoCallUint64Result IoSocketHandleImpl::recv(void* buffer, size_t length, int flags) {

  const Api::SysCallSizeResult result =

      Api::OsSysCallsSingleton::get().recv(fd_, buffer, length, flags);

  return sysCallResultToIoCallResult(result);

}

Api::SysCallIntResult IoSocketHandleImpl::bind(Address::InstanceConstSharedPtr address) {

  return Api::OsSysCallsSingleton::get().bind(fd_, address->sockAddr(), address->sockAddrLen());

}

Api::SysCallIntResult IoSocketHandleImpl::listen(int backlog) {

  return Api::OsSysCallsSingleton::get().listen(fd_, backlog);

}

IoHandlePtr IoSocketHandleImpl::accept(struct sockaddr* addr, socklen_t* addrlen) {

  auto result = Api::OsSysCallsSingleton::get().accept(fd_, addr, addrlen);

  if (SOCKET_INVALID(result.return_value_)) {

    return nullptr;

  }

  return SocketInterfaceImpl::makePlatformSpecificSocket(result.return_value_, socket_v6only_,

                                                         domain_, {});

}

Api::SysCallIntResult IoSocketHandleImpl::connect(Address::InstanceConstSharedPtr address) {

  auto sockaddr_to_use = address->sockAddr();

  auto sockaddr_len_to_use = address->sockAddrLen();

  auto result = Api::OsSysCallsSingleton::get().connect(fd_, sockaddr_to_use, sockaddr_len_to_use);

  if (result.return_value_ != -1) {

    was_connected_ = true;

  }

  return result;

}

IoHandlePtr IoSocketHandleImpl::duplicate() {

  auto result = Api::OsSysCallsSingleton::get().duplicate(fd_);

  RELEASE_ASSERT(result.return_value_ != -1,

                 fmt::format("duplicate failed for '{}': ({}) {}", fd_, result.errno_,

                             errorDetails(result.errno_)));

  return SocketInterfaceImpl::makePlatformSpecificSocket(result.return_value_, socket_v6only_,

                                                         domain_, {false, addressCacheMaxSize()});

}

                                             Event::FileTriggerType trigger, uint32_t events) {

  ASSERT(file_event_ == nullptr, "Attempting to initialize two `file_event_` for the same "

                                 "file descriptor. This is not allowed.");

  file_event_ = dispatcher.createFileEvent(fd_, cb, trigger, events);

}

void IoSocketHandleImpl::activateFileEvents(uint32_t events) {

  if (file_event_) {

    file_event_->activate(events);

  } else {

    ENVOY_BUG(false, "Null file_event_");

  }

}

void IoSocketHandleImpl::enableFileEvents(uint32_t events) {

  if (file_event_) {

    file_event_->setEnabled(events);

  } else {

}

Api::SysCallIntResult IoSocketHandleImpl::shutdown(int how) {

  return Api::OsSysCallsSingleton::get().shutdown(fd_, how);

}