[[maybe_unused]] bool hasIoUringWorkerFactory(Io::IoUringWorkerFactory* io_uring_worker_factory) {

  return io_uring_worker_factory != nullptr && io_uring_worker_factory->currentThreadRegistered() &&

         io_uring_worker_factory->getIoUringWorker() != absl::nullopt;

}

void DefaultSocketInterfaceExtension::onWorkerThreadInitialized() {

  if (io_uring_worker_factory_ != nullptr) {

    io_uring_worker_factory_->onWorkerThreadInitialized();

  }

}

    [[maybe_unused]] Io::IoUringWorkerFactory* io_uring_worker_factory) {

#if defined(__linux__) && !defined(__ANDROID_API__) && defined(ENVOY_ENABLE_IO_URING)

  if (hasIoUringWorkerFactory(io_uring_worker_factory)) {

    return std::make_unique<IoUringSocketHandleImpl>(*io_uring_worker_factory, socket_fd,

                                                     socket_v6only, domain);

  }

#endif

  return std::make_unique<IoSocketHandleImpl>(socket_fd, socket_v6only, domain,

                                              options.max_addresses_cache_size_);

}

                                            const SocketCreationOptions& options) const {

  if (socket_type == Socket::Type::Datagram) {

    return makePlatformSpecificSocket(socket_fd, socket_v6only, domain, options, nullptr);

  }

  return makePlatformSpecificSocket(socket_fd, socket_v6only, domain, options,

                                    io_uring_worker_factory_.lock().get());

}

                                        const SocketCreationOptions& options) const {

  int protocol = 0;

  int flags = SOCK_NONBLOCK;

  if (hasIoUringWorkerFactory(io_uring_worker_factory_.lock().get()) &&

      socket_type == Socket::Type::Stream) {

    flags = 0;

  }

  if (options.mptcp_enabled_) {

    ASSERT(socket_type == Socket::Type::Stream);

    ASSERT(addr_type == Address::Type::Ip);

    protocol = IPPROTO_MPTCP;

  }

#endif

  if (socket_type == Socket::Type::Stream) {

    flags |= SOCK_STREAM;

  } else {

    flags |= SOCK_DGRAM;

  }

  int domain;

  if (addr_type == Address::Type::Ip) {

    if (version == Address::IpVersion::v6 || Address::forceV6()) {

      domain = AF_INET6;

    } else {

      ASSERT(version == Address::IpVersion::v4);

      domain = AF_INET;

    }

  } else if (addr_type == Address::Type::Pipe) {

    domain = AF_UNIX;

  } else {

  const Api::SysCallSocketResult result =

      Api::OsSysCallsSingleton::get().socket(domain, flags, protocol);

  if (!SOCKET_VALID(result.return_value_)) {

    IS_ENVOY_BUG(fmt::format("socket(2) failed, got error: {}", errorDetails(result.errno_)));

    return nullptr;

  }

  IoHandlePtr io_handle =

      makeSocket(result.return_value_, socket_v6only, socket_type, domain, options);

  return io_handle;

}

                                        const SocketCreationOptions& options) const {

  Address::IpVersion ip_version = addr->ip() ? addr->ip()->version() : Address::IpVersion::v4;

  int v6only = 0;

  if (addr->type() == Address::Type::Ip && ip_version == Address::IpVersion::v6) {

    v6only = addr->ip()->ipv6()->v6only();

  }

  IoHandlePtr io_handle =

      SocketInterfaceImpl::socket(socket_type, addr->type(), ip_version, v6only, options);

  if (io_handle && addr->type() == Address::Type::Ip && ip_version == Address::IpVersion::v6 &&

      !Address::forceV6()) {

    const Api::SysCallIntResult result = io_handle->setOption(

        IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char*>(&v6only), sizeof(v6only));

    ENVOY_BUG(!SOCKET_FAILURE(result.return_value_),

              fmt::format("Unable to set socket v6-only: got error: {}", result.return_value_));

  }

  return io_handle;

}

bool SocketInterfaceImpl::ipFamilySupported(int domain) {

  Api::OsSysCalls& os_sys_calls = Api::OsSysCallsSingleton::get();

  const Api::SysCallSocketResult result = os_sys_calls.socket(domain, SOCK_STREAM, 0);

  if (SOCKET_VALID(result.return_value_)) {

    RELEASE_ASSERT(

        os_sys_calls.close(result.return_value_).return_value_ == 0,

        fmt::format("Fail to close fd: response code {}", errorDetails(result.return_value_)));

  }

  return SOCKET_VALID(result.return_value_);

}

    [[maybe_unused]] Server::Configuration::ServerFactoryContext& context) {

#if defined(__linux__) && !defined(__ANDROID_API__) && defined(ENVOY_ENABLE_IO_URING)

  const auto& message = MessageUtil::downcastAndValidate<

      const envoy::extensions::network::socket_interface::v3::DefaultSocketInterface&>(

      config, context.messageValidationVisitor());

  if (message.has_io_uring_options() && Io::isIoUringSupported()) {

    const auto& options = message.io_uring_options();

    std::shared_ptr<Io::IoUringWorkerFactoryImpl> io_uring_worker_factory =

        std::make_shared<Io::IoUringWorkerFactoryImpl>(

            PROTOBUF_GET_WRAPPED_OR_DEFAULT(options, io_uring_size, 1000),

            options.enable_submission_queue_polling(),

            PROTOBUF_GET_WRAPPED_OR_DEFAULT(options, read_buffer_size, 8192),

            PROTOBUF_GET_WRAPPED_OR_DEFAULT(options, write_timeout_ms, 1000),

            context.threadLocal());

    io_uring_worker_factory_ = io_uring_worker_factory;

    return std::make_unique<DefaultSocketInterfaceExtension>(*this, io_uring_worker_factory);

  } else {

    return std::make_unique<DefaultSocketInterfaceExtension>(*this, nullptr);

  }

}

ProtobufTypes::MessagePtr SocketInterfaceImpl::createEmptyConfigProto() {

  return std::make_unique<

      envoy::extensions::network::socket_interface::v3::DefaultSocketInterface>();

}