Method receiveHello

src/Client/Connection.cpp:567–666

void Connection::receiveHello()
{
    /// Receive hello packet.
    UInt64 packet_type = 0;

    /// Prevent read after eof in readVarUInt in case of reset connection
    /// (Poco should throw such exception while reading from socket but
    /// sometimes it doesn't for unknown reason)
    if (in->eof())
        throw Poco::Net::NetException("Connection reset by peer");

    readVarUInt(packet_type, *in);
    if (packet_type == Protocol::Server::Hello)
    {
        readStringBinary(server_name, *in, DBMS_MAX_HELLO_STRING_SIZE);
        sanitizeUntrustedServerString(server_name);
        readVarUInt(server_version_major, *in);
        readVarUInt(server_version_minor, *in);
        readVarUInt(server_revision, *in);
        if (server_revision >= DBMS_MIN_REVISION_WITH_VERSIONED_PARALLEL_REPLICAS_PROTOCOL)
            readVarUInt(server_parallel_replicas_protocol_version, *in);
        if (server_revision >= DBMS_MIN_REVISION_WITH_SERVER_TIMEZONE)
        {
            readStringBinary(server_timezone, *in, DBMS_MAX_HELLO_STRING_SIZE);
            sanitizeUntrustedServerString(server_timezone);
        }
        if (server_revision >= DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME)
        {
            readStringBinary(server_display_name, *in, DBMS_MAX_HELLO_STRING_SIZE);
            sanitizeUntrustedServerString(server_display_name);
        }
        if (server_revision >= DBMS_MIN_REVISION_WITH_VERSION_PATCH)
            readVarUInt(server_version_patch, *in);
        else
            server_version_patch = server_revision;

        if (server_revision >= DBMS_MIN_PROTOCOL_VERSION_WITH_CHUNKED_PACKETS)
        {
            /// These are tiny protocol tokens ("chunked" / "notchunked") compared in
            /// `is_chunked`; cap them so a hostile server cannot force a large allocation.
            readStringBinary(proto_send_chunked_srv, *in, DBMS_MAX_HELLO_STRING_SIZE);
            readStringBinary(proto_recv_chunked_srv, *in, DBMS_MAX_HELLO_STRING_SIZE);
        }

        if (server_revision >= DBMS_MIN_PROTOCOL_VERSION_WITH_PASSWORD_COMPLEXITY_RULES)
        {
            UInt64 rules_size = 0;
            readVarUInt(rules_size, *in);
            /// `rules_size` is server-controlled and feeds a `reserve`; reject absurd
            /// values so a hostile server cannot force a huge allocation. The server
            /// enforces the same cap at construction time (see TCPHandler::sendHello).
            if (rules_size > DBMS_MAX_PASSWORD_COMPLEXITY_RULES)
                throw Exception(ErrorCodes::UNEXPECTED_PACKET_FROM_SERVER,
                    "Server declared {} password-complexity rules, maximum allowed is {}",
                    rules_size, DBMS_MAX_PASSWORD_COMPLEXITY_RULES);
            password_complexity_rules.reserve(rules_size);

            for (size_t i = 0; i < rules_size; ++i)