Method SendCachedBodyResponse

src/libs/ec/cpp/ECSocket.cpp:868–991

void CECSocket::SendCachedBodyResponse(uint8_t opcode,
	const std::vector<std::shared_ptr<const std::vector<unsigned char> > > &blobs)
{
	if (SocketRealError()) {
		OnError();
		return;
	}

	// Remember where in the output queue our bytes start, so the
	// length-patch at the end touches the right CQueuedData.
	std::list<CQueuedData*>::iterator outputStart = m_output_queue.begin();
	uint32 outputQueueSize = m_output_queue.size();
	for (uint32 i = 1; i < outputQueueSize; i++) {
		++outputStart;
	}

	// Sum the pre-serialized body length. Used both for the local-ZLIB-
	// bypass decision and as a budget hint — the actual on-wire length
	// is computed from the queue after FlushBuffers below.
	uint32 body_bytes = 0;
	for (size_t i = 0; i < blobs.size(); ++i) {
		if (blobs[i]) {
			body_bytes += (uint32)blobs[i]->size();
		}
	}

	// Same flag-byte logic as WritePacket. Cached blobs were
	// serialized assuming UTF-8 numbers + LARGE_TAG_COUNT, so both
	// bits must end up in the wire flag; we OR them in unconditionally
	// and then mask against m_my_flags — callers should only invoke
	// this method on connections that negotiated both capabilities.
	uint32_t flags = 0x20;
	const bool local_bypass_zlib = m_isLocalPeer
		&& body_bytes <= kLocalPeerZlibBypassMax;
	if (body_bytes > EC_MAX_UNCOMPRESSED
		&& ((m_my_flags & EC_FLAG_ZLIB) > 0)
		&& !local_bypass_zlib) {
		flags |= EC_FLAG_ZLIB;
	}
	flags |= EC_FLAG_UTF8_NUMBERS;
	flags |= EC_FLAG_LARGE_TAG_COUNT;
	flags &= m_my_flags;
	m_tx_flags = flags;

	if (flags & EC_FLAG_ZLIB) {
		m_z.zalloc = Z_NULL;
		m_z.zfree = Z_NULL;
		m_z.opaque = Z_NULL;
		m_z.avail_in = 0;
		m_z.next_in = &m_in_ptr[0];
		int zerror = deflateInit(&m_z, EC_COMPRESSION_LEVEL);
		if (zerror != Z_OK) {
			flags &= ~EC_FLAG_ZLIB;
			ShowZError(zerror, &m_z);
		}
	}

	uint32_t tmp_flags = ENDIAN_HTONL(flags);