100 tasks from the HWE arm-linux code-gen pool (outside the lk/man/pth range given to batch 22), each with at least one independent contract-edge defect and plain public docs. Claude reviewed 100/100 USABLE against current digests; no ID or source overlap with main or batch 22. Difficulty is unmeasured. progress.md records the wrap-up: all Codex sessions and Qwen schedulers stopped for the user's rollout, Qwen results so far (57 HARD of 373), and what is left on each batch branch. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
208 lines
5.4 KiB
C++
208 lines
5.4 KiB
C++
#include "stream.hpp"
|
|
#include <limits>
|
|
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<std::uint8_t>((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<std::int64_t>(mode)));
|
|
}
|
|
case 3:
|
|
return integer_reply(static_cast<std::uint64_t>(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<std::uint64_t>(value.captured_mode));
|
|
Reply reply;
|
|
reply.payload = writer.take();
|
|
return reply;
|
|
}
|
|
case 12: {
|
|
const std::vector<std::uint64_t> 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);
|
|
}
|
|
}
|
|
}
|