One user-space repair task per eligible HWE debug-diag / compile-deploy base ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content filter. Each ships a public spec with a check-to-basis table, at least two defects with single-fix fixtures, a symptom-masking fixture and an alternative correct implementation. Claude re-checked all 320: structure, the HWE quality items and trace6 Docker calibration receipts against current digests (320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120 ad-hoc family names; the next batch maps them to the canonical list. The batch's 1,256-line progress log stays in its factory report and the 36-local branch batch15-hwe. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
193 lines
4.5 KiB
C
193 lines
4.5 KiB
C
#include "relay_internal.h"
|
|
#include <limits.h>
|
|
#include <stddef.h>
|
|
|
|
static int relay_status_priority(enum relay_status status)
|
|
{
|
|
switch (status) {
|
|
case RELAY_OK:
|
|
return 0;
|
|
case RELAY_CLOSE_ERROR:
|
|
return 1;
|
|
case RELAY_WRITE_ERROR:
|
|
return 2;
|
|
case RELAY_DUP_ERROR:
|
|
return 3;
|
|
case RELAY_OPEN_ERROR:
|
|
return 4;
|
|
case RELAY_BAD_PLAN:
|
|
return 5;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int relay_status_known(enum relay_status status)
|
|
{
|
|
return relay_status_priority(status) >= 0;
|
|
}
|
|
|
|
static enum relay_status relay_preferred(enum relay_status left,
|
|
enum relay_status right)
|
|
{
|
|
if (relay_status_priority(left) >= relay_status_priority(right)) {
|
|
return left;
|
|
}
|
|
return right;
|
|
}
|
|
|
|
static void relay_ledger_clear_handles(struct relay_ledger *ledger)
|
|
{
|
|
ledger->original = -1;
|
|
ledger->duplicate = -1;
|
|
ledger->have_original = 0;
|
|
ledger->have_duplicate = 0;
|
|
ledger->closed_original = 0;
|
|
ledger->closed_duplicate = 0;
|
|
}
|
|
|
|
static void relay_ledger_clear_progress(struct relay_ledger *ledger)
|
|
{
|
|
ledger->frames_done = 0;
|
|
ledger->bytes_written = 0;
|
|
ledger->frame_bytes = 0;
|
|
ledger->active_frame = 0;
|
|
}
|
|
|
|
void relay_ledger_init(struct relay_ledger *ledger)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
ledger->status = RELAY_OK;
|
|
relay_ledger_clear_handles(ledger);
|
|
relay_ledger_clear_progress(ledger);
|
|
}
|
|
|
|
void relay_ledger_open(struct relay_ledger *ledger, int descriptor)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (descriptor < 0) {
|
|
relay_ledger_failure(ledger, RELAY_OPEN_ERROR);
|
|
return;
|
|
}
|
|
ledger->original = descriptor;
|
|
ledger->have_original = 1;
|
|
}
|
|
|
|
void relay_ledger_duplicate(struct relay_ledger *ledger, int descriptor)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (descriptor < 0) {
|
|
relay_ledger_failure(ledger, RELAY_DUP_ERROR);
|
|
return;
|
|
}
|
|
ledger->duplicate = descriptor;
|
|
ledger->have_duplicate = 1;
|
|
}
|
|
|
|
void relay_ledger_begin(struct relay_ledger *ledger, size_t index)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
ledger->active_frame = index;
|
|
ledger->frame_bytes = 0;
|
|
}
|
|
|
|
static int relay_add_would_overflow(size_t left, size_t right)
|
|
{
|
|
return right > ((size_t)-1) - left;
|
|
}
|
|
|
|
void relay_ledger_advance(struct relay_ledger *ledger, size_t count)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (relay_add_would_overflow(ledger->bytes_written, count)) {
|
|
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
|
|
return;
|
|
}
|
|
if (relay_add_would_overflow(ledger->frame_bytes, count)) {
|
|
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
|
|
return;
|
|
}
|
|
ledger->bytes_written += count;
|
|
ledger->frame_bytes += count;
|
|
}
|
|
|
|
void relay_ledger_finish(struct relay_ledger *ledger, size_t packet_length)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (ledger->status != RELAY_OK) {
|
|
return;
|
|
}
|
|
if (ledger->frame_bytes != packet_length) {
|
|
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
|
|
return;
|
|
}
|
|
if (ledger->active_frame != ledger->frames_done) {
|
|
relay_ledger_failure(ledger, RELAY_WRITE_ERROR);
|
|
return;
|
|
}
|
|
++ledger->frames_done;
|
|
}
|
|
|
|
void relay_ledger_failure(struct relay_ledger *ledger, enum relay_status status)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (!relay_status_known(status)) {
|
|
return;
|
|
}
|
|
ledger->status = relay_preferred(ledger->status, status);
|
|
}
|
|
|
|
void relay_ledger_closed(struct relay_ledger *ledger, int descriptor)
|
|
{
|
|
if (ledger == NULL) {
|
|
return;
|
|
}
|
|
if (ledger->have_duplicate && descriptor == ledger->duplicate) {
|
|
ledger->closed_duplicate = 1;
|
|
return;
|
|
}
|
|
if (ledger->have_original && descriptor == ledger->original) {
|
|
ledger->closed_original = 1;
|
|
}
|
|
}
|
|
|
|
static size_t relay_visible_frames(const struct relay_ledger *ledger)
|
|
{
|
|
if (ledger->frames_done > 24) {
|
|
return 24;
|
|
}
|
|
return ledger->frames_done;
|
|
}
|
|
|
|
static enum relay_status relay_visible_status(const struct relay_ledger *ledger)
|
|
{
|
|
if (!relay_status_known(ledger->status)) {
|
|
return RELAY_WRITE_ERROR;
|
|
}
|
|
return ledger->status;
|
|
}
|
|
|
|
void relay_ledger_publish(const struct relay_ledger *ledger,
|
|
struct relay_report *report)
|
|
{
|
|
if (ledger == NULL || report == NULL) {
|
|
return;
|
|
}
|
|
report->status = relay_visible_status(ledger);
|
|
report->frames_done = relay_visible_frames(ledger);
|
|
report->bytes_written = ledger->bytes_written;
|
|
}
|