From the 101 lk/man/pth code-gen sources: 63 tasks (C11 36, C++17 27, 11 canonical families), 38 skipped for scope or duplication. Each task has at least one independent contract-edge defect, boundary types rotate, and public docs state trap clauses as plain contract prose. Claude reviewed 63/63 USABLE against current digests. Difficulty is unmeasured. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
125 lines
3.2 KiB
C++
125 lines
3.2 KiB
C++
#include "capture.hpp"
|
|
#include <sstream>
|
|
|
|
namespace capture {
|
|
namespace {
|
|
int nibble(char value)
|
|
{
|
|
if (value >= '0' && value <= '9') {
|
|
return value - '0';
|
|
}
|
|
if (value >= 'a' && value <= 'f') {
|
|
return value - 'a' + 10;
|
|
}
|
|
if (value >= 'A' && value <= 'F') {
|
|
return value - 'A' + 10;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
Status decode_hex(const std::string& text, std::vector<std::uint8_t>* out)
|
|
{
|
|
if (out == nullptr) {
|
|
return Status::invalid;
|
|
}
|
|
if (text == "-") {
|
|
out->clear();
|
|
return Status::ok;
|
|
}
|
|
if (text.empty() || text.size() % 2 != 0) {
|
|
return Status::invalid;
|
|
}
|
|
for (char value : text) {
|
|
if (nibble(value) < 0) {
|
|
return Status::invalid;
|
|
}
|
|
}
|
|
if (text.size() / 2 > payload_limit) {
|
|
return Status::capacity;
|
|
}
|
|
std::vector<std::uint8_t> decoded;
|
|
decoded.reserve(text.size() / 2);
|
|
for (std::size_t cursor = 0; cursor < text.size(); cursor += 2) {
|
|
unsigned high = static_cast<unsigned>(nibble(text[cursor]));
|
|
unsigned low = static_cast<unsigned>(nibble(text[cursor + 1]));
|
|
decoded.push_back(static_cast<std::uint8_t>((high << 4) | low));
|
|
}
|
|
*out = decoded;
|
|
return Status::ok;
|
|
}
|
|
|
|
Status encode_hex(const std::vector<std::uint8_t>& data, std::string* out)
|
|
{
|
|
if (out == nullptr) {
|
|
return Status::invalid;
|
|
}
|
|
if (data.size() > payload_limit) {
|
|
return Status::capacity;
|
|
}
|
|
if (data.empty()) {
|
|
*out = "-";
|
|
return Status::ok;
|
|
}
|
|
static const char digits[] = "0123456789abcdef";
|
|
std::string encoded;
|
|
encoded.reserve(data.size() * 2);
|
|
for (std::uint8_t value : data) {
|
|
encoded.push_back(digits[value >> 4]);
|
|
encoded.push_back(digits[value & 15]);
|
|
}
|
|
*out = encoded;
|
|
return Status::ok;
|
|
}
|
|
|
|
std::uint32_t payload_digest(const std::vector<std::uint8_t>& data)
|
|
{
|
|
std::uint32_t digest = 2166136261u;
|
|
for (std::uint8_t value : data) {
|
|
digest ^= value;
|
|
digest *= 16777619u;
|
|
}
|
|
return digest;
|
|
}
|
|
|
|
const char* status_name(Status status)
|
|
{
|
|
switch (status) {
|
|
case Status::ok:
|
|
return "OK";
|
|
case Status::invalid:
|
|
return "INVALID";
|
|
case Status::range:
|
|
return "RANGE";
|
|
case Status::missing:
|
|
return "MISSING";
|
|
case Status::capacity:
|
|
return "CAPACITY";
|
|
}
|
|
return "INVALID";
|
|
}
|
|
|
|
Status format_entry(const Entry& entry, std::string* out)
|
|
{
|
|
if (out == nullptr || !entry.present || entry.stamp.nsec < 0 ||
|
|
entry.stamp.nsec >= 1000000000 || entry.sequence == 0 ||
|
|
entry.sequence > capture_limit || entry.payload.size() > payload_limit) {
|
|
return Status::invalid;
|
|
}
|
|
std::string encoded;
|
|
Status status = encode_hex(entry.payload, &encoded);
|
|
if (status != Status::ok) {
|
|
return status;
|
|
}
|
|
std::ostringstream stream;
|
|
stream << "{\"sec\":" << entry.stamp.sec;
|
|
stream << ",\"nsec\":" << entry.stamp.nsec;
|
|
stream << ",\"sequence\":" << entry.sequence;
|
|
stream << ",\"length\":" << entry.payload.size();
|
|
stream << ",\"hex\":\"" << encoded << "\"";
|
|
stream << ",\"hash\":" << payload_digest(entry.payload) << "}";
|
|
*out = stream.str();
|
|
return Status::ok;
|
|
}
|
|
}
|