Http2.cpp

#include "Http2.h"
#include "../../utils/Utils.h"

namespace Http2
{
	bool operator &(const FrameFlag left, const FrameFlag right) noexcept {
		return static_cast<const uint8_t>(left) & static_cast<const uint8_t>(right);
	}

	FrameFlag operator |(const FrameFlag left, const FrameFlag right) noexcept {
		return static_cast<FrameFlag>(static_cast<const uint8_t>(left) | static_cast<const uint8_t>(right) );
	}

	FrameFlag operator |=(FrameFlag &left, const FrameFlag right) noexcept {
		return static_cast<FrameFlag>(*reinterpret_cast<uint8_t *>(&left) |= static_cast<const uint8_t>(right) );
	}

	ConnectionSettings ConnectionSettings::defaultSettings() noexcept {
		return ConnectionSettings {
			4096,
			1,
			0,
			(1 << 16) - 1, // 65535
			1 << 14, // 16384
			0
		};
	}

	DynamicTable::DynamicTable() noexcept
		: header_table_size(0), max_header_list_size(0), cur_header_list_size(0)
	{

	}

	size_t DynamicTable::size() const noexcept {
		return this->list.size();
	}

	DynamicTable::DynamicTable(const uint32_t headerTableSize, const uint32_t maxHeaderListSize, std::deque<std::pair<std::string, std::string> > &&list) noexcept
		: list(std::move(list) ), header_table_size(headerTableSize), max_header_list_size(maxHeaderListSize), cur_header_list_size(0)
	{
		for (auto const &pair : list) {
			this->cur_header_list_size += pair.first.length() + pair.second.length();
		}
	}

	void DynamicTable::addHeader(const std::pair<std::string, std::string> &header)
	{
		this->cur_header_list_size += header.first.length() + header.second.length();

		this->list.emplace_front(header);

		while (this->list.size() > this->header_table_size || (0 != this->max_header_list_size && this->cur_header_list_size > this->max_header_list_size) )
		{
			auto const &pair = this->list.back();

			this->cur_header_list_size -= pair.first.length() + pair.second.length();

			this->list.pop_back();
		}
	}

	void DynamicTable::addHeader(std::pair<std::string, std::string> &&header)
	{
		this->cur_header_list_size += header.first.length() + header.second.length();

		this->list.emplace_front(std::move(header) );

		while (this->list.size() > this->header_table_size || (0 != this->max_header_list_size && this->cur_header_list_size > this->max_header_list_size) )
		{
			auto const &pair = this->list.back();

			this->cur_header_list_size -= pair.first.length() + pair.second.length();

			this->list.pop_back();
		}
	}

	void DynamicTable::changeHeaderTableSize(const uint32_t headerTableSize)
	{
		this->header_table_size = headerTableSize;

		while (this->list.size() > this->header_table_size) {
			auto const &pair = this->list.back();

			this->cur_header_list_size -= pair.first.length() + pair.second.length();

			this->list.pop_back();
		}
	}

	void DynamicTable::changeMaxHeaderListSize(const uint32_t maxHeaderListSize)
	{
		this->max_header_list_size = maxHeaderListSize;

		while (0 != this->max_header_list_size && this->cur_header_list_size > this->max_header_list_size)
		{
			auto const &pair = this->list.back();

			this->cur_header_list_size -= pair.first.length() + pair.second.length();

			this->list.pop_back();
		}
	}

	const std::pair<std::string, std::string> &DynamicTable::operator[](const size_t index) const noexcept {
		return this->list[index];
	}

	std::pair<std::string, std::string> &DynamicTable::operator[](const size_t index) noexcept {
		return this->list[index];
	}

	const std::deque<std::pair<std::string, std::string> > &DynamicTable::getList() const noexcept {
		return this->list;
	}

	IncStream::IncStream(const uint32_t streamId, ConnectionData &conn) noexcept
		: conn(conn), window_size_inc(conn.server_settings.initial_window_size),
		  window_size_out(conn.client_settings.initial_window_size), stream_id(streamId),
		  state(StreamState::IDLE), priority(0), reserved(nullptr)
	{

	}

	uint8_t *IncStream::setHttp2FrameHeader(uint8_t *addr, const uint32_t frameSize, const Http2::FrameType frameType, const Http2::FrameFlag frameFlags) noexcept
	{
		Utils::hton24(addr, frameSize);
		*(addr + 3) = static_cast<const uint8_t>(frameType);
		*(addr + 4) = static_cast<const uint8_t>(frameFlags);
		*reinterpret_cast<uint32_t *>(addr + 5) = ::htonl(this->stream_id);

		return (addr + Http2::FRAME_HEADER_SIZE);
	}

	void IncStream::lock() {
		this->conn.sync.mtx.lock();
	}

	void IncStream::unlock() noexcept {
		this->conn.sync.mtx.unlock();
	}

	void IncStream::close() noexcept
	{
		this->incoming_headers.clear();
		this->incoming_data.clear();
		this->incoming_files.clear();
		this->reserved = nullptr;

		++this->conn.sync.completed;
		this->conn.sync.event.notify();

	//	this->state = StreamState::CLOSED;
	}

	OutStream::OutStream(const uint32_t streamId, const ConnectionSettings &settings, DynamicTable &&dynamic_table, std::mutex *mtx) noexcept
		: stream_id(streamId), settings(settings), window_size_out(settings.initial_window_size), dynamic_table(std::move(dynamic_table) ), mtx(mtx)
	{

	}

	OutStream::OutStream(const IncStream &stream)
		: stream_id(stream.stream_id), settings(stream.conn.client_settings),
		  window_size_out(stream.window_size_out), dynamic_table(stream.conn.encoding_dynamic_table), mtx(&stream.conn.sync.mtx)
	{

	}

	uint8_t *OutStream::setHttp2FrameHeader(uint8_t *addr, const uint32_t frameSize, const Http2::FrameType frameType, const Http2::FrameFlag frameFlags) noexcept
	{
		Utils::hton24(addr, frameSize);
		*(addr + 3) = static_cast<const uint8_t>(frameType);
		*(addr + 4) = static_cast<const uint8_t>(frameFlags);
		*reinterpret_cast<uint32_t *>(addr + 5) = ::htonl(this->stream_id);

		return (addr + Http2::FRAME_HEADER_SIZE);
	}

	void OutStream::lock() {
		this->mtx->lock();
	}

	void OutStream::unlock() noexcept {
		this->mtx->unlock();
	}
}