Method startServers

programs/local/LocalServer.cpp:569–834

void LocalServer::startServers(const ServerType & server_type)
{
    validateLocalServerListenType(server_type);

    const auto & config = getClientConfiguration();
    const Settings & settings = global_context->getSettingsRef();

    /// The configured `tcp_port` / `http_port` is the port that the listener binds, and `createServer`
    /// casts it to `UInt16`, so a value outside `0..65535` would silently wrap (`-1` -> `65535`,
    /// `70000` -> `4464`) and bring the listener up on an unexpected port. `--tcp_port` / `--http_port`
    /// are already range-checked when parsed, but a value coming from a loaded config file reaches this
    /// path unchecked, so validate the effective value here for every protocol being started. `0` means
    /// an OS-assigned port and is allowed.
    auto validate_port_range = [&](const char * port_name)
    {
        if (!config.has(port_name))
            return;
        Int64 port = config.getInt64(port_name);
        if (port < 0 || port > 65535)
            throw Exception(
                ErrorCodes::BAD_ARGUMENTS,
                "Invalid value {} for {}: a port number must be in the range 0..65535 (use 0 for an OS-assigned port)",
                port, port_name);
    };
    if (server_type.shouldStart(ServerType::Type::TCP))
        validate_port_range("tcp_port");
    if (server_type.shouldStart(ServerType::Type::HTTP))
        validate_port_range("http_port");

    /// An explicit `--listen_host` on the command line is a hard override: bind only that single host
    /// and ignore any `listen_host` entries from a loaded config file. This matters because
    /// `getMultipleValuesFromConfig` returns the union of repeated `listen_host[...]` keys across all
    /// configuration layers, so a plain `config.setString("listen_host", ...)` would replace only the
    /// first entry and leave lower-priority hosts (possibly non-loopback) from the config still bound,
    /// defeating the documented hardening path.
    std::vector<std::string> listen_hosts;
    if (cli_listen_host.has_value())
        listen_hosts.emplace_back(*cli_listen_host);
    else
        listen_hosts = DB::getMultipleValuesFromConfig(config, "", "listen_host");

    const bool hosts_explicitly_configured = !listen_hosts.empty();
    if (listen_hosts.empty())
    {
        listen_hosts.emplace_back("::1");
        listen_hosts.emplace_back("127.0.0.1");
    }

    /// Mirror `clickhouse-server`'s `getListenTry`: honor an explicit `listen_try` server setting,
    /// and otherwise fall back to `listen_try=true` only when the user has not named any host
    /// explicitly (so the implicit `::1` + `127.0.0.1` defaults don't fail on a host without
    /// IPv6). When the user names hosts explicitly with `listen_try=0`, surface bind failures.
    bool listen_try = server_settings[ServerSetting::listen_try];
    if (!listen_try)
        listen_try = !hosts_explicitly_configured;

    /// `getServerPort` stores a single value per `port_name`, so an OS-assigned ephemeral
    /// port (`port=0`) combined with multiple `listen_host` values would produce an