#include "stream.hpp" #include namespace captured { namespace { class Reader { public: explicit Reader(const Bytes& bytes) : bytes_(bytes), cursor_(4) { } std::size_t remaining() const { return bytes_.size() - cursor_; } std::uint64_t integer() { std::uint64_t value = 0; for (unsigned shift = 0; shift < 64; shift += 8) { const std::uint64_t byte = bytes_[cursor_]; value |= byte << shift; ++cursor_; } return value; } Bytes rest() { Bytes value(bytes_.begin() + cursor_, bytes_.end()); cursor_ = bytes_.size(); return value; } private: const Bytes& bytes_; std::size_t cursor_; }; class Writer { public: void integer(std::uint64_t value) { for (unsigned shift = 0; shift < 64; shift += 8) { bytes_.push_back(static_cast((value >> shift) & 255)); } } void bytes(const Bytes& value) { bytes_.insert(bytes_.end(), value.begin(), value.end()); } Bytes take() { return std::move(bytes_); } private: Bytes bytes_; }; Reply rejected(int status) { Reply reply; reply.status = status; return reply; } Reply status_only(int status) { return rejected(status); } Reply integer_reply(std::uint64_t value) { Writer writer; writer.integer(value); Reply reply; reply.payload = writer.take(); return reply; } Reply bytes_reply(const Result& result) { if (result.status != 0) { return rejected(result.status); } Writer writer; writer.integer(result.count); writer.bytes(result.data); Reply reply; reply.payload = writer.take(); return reply; } std::size_t argument_bytes(std::uint8_t opcode) { switch (opcode) { case 1: case 2: case 6: case 7: case 8: case 9: case 11: return 8; case 4: return 16; case 3: case 10: case 12: case 13: return 0; default: return 24; } } } Reply Device::packet(const Bytes& request) { if (request.size() < 4 || request.size() > 131072) { return rejected(-71); } if (request[0] != 'M' || request[1] != 'S' || request[2] != 1) { return rejected(-71); } const std::uint8_t opcode = request[3]; if (opcode < 1 || opcode > 13) { return rejected(-25); } Reader reader(request); if (opcode == 5) { if (reader.remaining() < 24) { return rejected(-71); } const std::uint64_t id = reader.integer(); const std::uint64_t budget = reader.integer(); const std::uint64_t length = reader.integer(); if (length > 65535 || length != reader.remaining()) { return rejected(-71); } const Bytes data = reader.rest(); const Result result = append(id, data, budget); if (result.status != 0) { return rejected(result.status); } return integer_reply(result.count); } if (reader.remaining() != argument_bytes(opcode)) { return rejected(-71); } switch (opcode) { case 1: { const std::uint64_t cap = reader.integer(); return status_only(reset(cap)); } case 2: { const std::uint64_t mode = reader.integer(); if (mode > 2) { return rejected(-22); } return status_only(set_mode(static_cast(mode))); } case 3: return integer_reply(static_cast(get_mode())); case 4: { const std::uint64_t id = reader.integer(); const std::uint64_t total = reader.integer(); return status_only(begin(id, total)); } case 6: { const std::uint64_t id = reader.integer(); return status_only(finish(id)); } case 7: { const std::uint64_t id = reader.integer(); return status_only(cancel(id)); } case 8: { const std::uint64_t count = reader.integer(); return bytes_reply(read(count)); } case 9: { const std::uint64_t count = reader.integer(); return bytes_reply(peek(count)); } case 10: { const Stats value = stats(); Writer writer; writer.integer(value.accepted); writer.integer(value.consumed); writer.integer(value.completed); writer.integer(value.canceled); writer.integer(value.buffered); writer.integer(value.active); Reply reply; reply.payload = writer.take(); return reply; } case 11: { const std::uint64_t id = reader.integer(); const Snapshot value = inspect(id); if (value.status != 0) { return rejected(value.status); } Writer writer; writer.integer(value.id); writer.integer(value.total); writer.integer(value.accepted); writer.integer(value.remaining); writer.integer(static_cast(value.captured_mode)); Reply reply; reply.payload = writer.take(); return reply; } case 12: { const std::vector ids = active_ids(); Writer writer; writer.integer(ids.size()); for (std::uint64_t id : ids) { writer.integer(id); } Reply reply; reply.payload = writer.take(); return reply; } case 13: return integer_reply(capacity()); default: return rejected(-25); } } }