Method trySendExceptionWithoutConnectionBuffers

src/Server/TCPHandler.cpp:3014–3075

void TCPHandler::trySendExceptionWithoutConnectionBuffers(const Exception & e)
{
    try
    {
        /// The connection failed to initialize most likely because the server memory limit
        /// is reached. In this state every tracked allocation throws, so the error handling
        /// path must be exempt from the memory limit: it allocates a small bounded amount
        /// (the strings of the exception message).
        LockMemoryExceptionInThread lock_memory_tracker(VariableContext::Global);

        /// The client has not received 'Hello' yet, so the communication is not chunked,
        /// and the client is able to receive an exception packet instead of the 'Hello'
        /// response (this is also how authentication errors are delivered). The stack
        /// trace is not sent: it is of little use, while it noticeably grows the packet.
        char stack_memory[4096];
        WriteBufferFromPocoSocket socket_out(socket(), sizeof(stack_memory), stack_memory);
        writeVarUInt(Protocol::Server::Exception, socket_out);
        writeException(e, socket_out, false /*with_stack_trace*/);
        socket_out.finalize();

        /// The client's 'Hello' packet is still unread in the socket receive queue.
        /// Closing the socket with pending unread data makes the kernel send RST,
        /// which can discard the exception packet written above before the client
        /// reads it. Read the pending data out, so the connection is terminated
        /// gracefully with FIN. There is no need to wait for more data: the client
        /// sends 'Hello' in a single packet before reading the response.
        /// The amount of drained data is limited in case the client keeps sending:
        /// such a connection is closed with RST, and that is fine.
        ssize_t max_bytes_to_drain = 65536;
        if (socket().secure())
        {
            /// For secure sockets available is `SSL_pending`, which only reports decrypted
            /// data buffered inside OpenSSL and misses the data in the socket receive queue,
            /// so the readiness of the underlying fd is polled instead. receiveBytes can
            /// block on a partially received TLS record, so the receive timeout is limited.
            socket().setReceiveTimeout(Poco::Timespan(0, 100'000 /*microseconds*/));
            while (max_bytes_to_drain > 0 && socket().poll(Poco::Timespan(), Poco::Net::Socket::SELECT_READ))
            {
                int bytes_received = socket().receiveBytes(stack_memory, sizeof(stack_memory));
                if (bytes_received <= 0)
                    break;
                max_bytes_to_drain -= bytes_received;
            }
        }
        else
        {
            /// For plain sockets available reflects the socket receive queue,
            /// and receiveBytes never blocks.
            while (max_bytes_to_drain > 0 && socket().available() > 0)
            {
                int bytes_received = socket().receiveBytes(stack_memory, sizeof(stack_memory));
                if (bytes_received <= 0)
                    break;
                max_bytes_to_drain -= bytes_received;
            }
        }
    }
    catch (...)