#include "progress.hpp" #include namespace progress { namespace { void put16(std::vector& target, std::uint32_t value) { target.push_back(value & 255); target.push_back((value >> 8) & 255); } void put32(std::vector& target, std::uint32_t value) { put16(target, value & 65535); put16(target, value >> 16); } std::uint32_t get16(const std::vector& data, std::size_t at) { const std::uint32_t low = data.at(at); const std::uint32_t high = data.at(at + 1); return low | (high << 8); } std::uint32_t get32(const std::vector& data, std::size_t at) { const std::uint32_t low = get16(data, at); const std::uint32_t high = get16(data, at + 2); return low | (high << 16); } std::uint32_t checksum(const std::vector& data, std::size_t count) { std::uint32_t crc = 65535; for (std::size_t index = 0; index < count; ++index) { crc ^= std::uint32_t(data.at(index)) << 8; for (unsigned bit = 0; bit < 8; ++bit) { const bool carry = (crc & 32768) != 0; crc = (crc << 1) & 65535; if (carry) { crc ^= 4129; } } } return crc; } void escaped_byte(std::vector& frame, std::uint8_t byte) { if (byte == 126 || byte == 125) { frame.push_back(125); frame.push_back(byte ^ 32); } else { frame.push_back(byte); } } } std::vector encode_certificate(const Certificate& certificate) { if (certificate.lane > 3 || certificate.job > 63 || certificate.unit > 31) { throw std::out_of_range("certificate position"); } if (certificate.word > 65535 || certificate.digest >= digest_mod) { throw std::out_of_range("certificate value"); } std::vector payload; payload.reserve(12); payload.push_back(1); payload.push_back(certificate.lane); payload.push_back(certificate.job); payload.push_back(certificate.unit); put16(payload, certificate.word); put32(payload, certificate.digest); const std::uint32_t crc = checksum(payload, payload.size()); put16(payload, crc); std::vector frame; frame.reserve(26); frame.push_back(126); for (std::uint8_t byte : payload) { escaped_byte(frame, byte); } frame.push_back(126); return frame; } void CertificateReceiver::append(std::uint8_t byte) { if (payload_.size() >= 12) { overflow_ = true; return; } payload_.push_back(byte); } void CertificateReceiver::close_frame() { if (escaped_ || overflow_ || payload_.size() != 12) { ++rejected_; return; } if (payload_[0] != 1 || payload_[1] > 3 || payload_[2] > 63 || payload_[3] > 31) { ++rejected_; return; } if (get16(payload_, 10) != checksum(payload_, 10)) { ++rejected_; return; } const std::uint32_t digest = get32(payload_, 6); if (digest >= digest_mod) { ++rejected_; return; } last_.lane = payload_[1]; last_.job = payload_[2]; last_.unit = payload_[3]; last_.word = get16(payload_, 4); last_.digest = digest; ++accepted_; } void CertificateReceiver::consume(std::uint8_t byte) { ++bytes_; audit_ = (std::uint64_t(audit_) * 29 + byte) % digest_mod; if (byte == 126) { if (active_) { close_frame(); active_ = false; } else { active_ = true; } payload_.clear(); escaped_ = false; overflow_ = false; return; } if (!active_) { return; } if (escaped_) { append(byte ^ 32); escaped_ = false; return; } if (byte == 125) { escaped_ = true; return; } append(byte); } const Certificate& CertificateReceiver::last() const { return last_; } std::uint32_t CertificateReceiver::bytes() const { return bytes_; } std::uint32_t CertificateReceiver::accepted() const { return accepted_; } std::uint32_t CertificateReceiver::rejected() const { return rejected_; } std::uint32_t CertificateReceiver::audit() const { return audit_; } }