amos 8b7616bfd8 Batch 22 (20261027-C-hwe-hard-22): add 63 calibrated HWE hard-design tasks
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>
2026-10-27 16:14:57 +08:00

268 lines
11 KiB
C

#include "descriptor.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void hexprint(const unsigned char *bytes, size_t count)
{
for (size_t i = 0; i < count; ++i) printf("%02x", bytes[i]);
}
static size_t unhex(const char *text, unsigned char *bytes)
{
if (!strcmp(text, "-")) return 0;
size_t size = strlen(text) / 2;
for (size_t i = 0; i < size; ++i) {
unsigned int value = 0;
sscanf(text + 2 * i, "%2x", &value);
bytes[i] = (unsigned char)value;
}
return size;
}
static void status(long long result, int error)
{
printf("{\"rc\":%lld,\"err\":%d}\n", result, result < 0 ? error : 0);
}
static FILE *local_file(void)
{
char path[] = "dr-observer-XXXXXX";
int fd = mkstemp(path);
if (fd < 0) return NULL;
unlink(path);
FILE *file = fdopen(fd, "w+");
if (!file) close(fd);
return file;
}
static void raw(const char *hex)
{
unsigned char bytes[DR_LIMIT], a[DR_LIMIT], b[DR_LIMIT];
size_t size = unhex(hex, bytes);
FILE *left = local_file(), *right = local_file();
if (!left || !right) exit(3);
int source = fileno(left), target = fileno(right);
if (write(source, bytes, size) != (ssize_t)size) exit(3);
if (write(target, "old", 3) != 3) exit(3);
lseek(source, 0, SEEK_SET);
lseek(target, 0, SEEK_SET);
errno = 0;
int flag_rc = dr_raw_cloexec(source, 1);
int flag_err = flag_rc < 0 ? errno : 0;
int before = fcntl(source, F_GETFD);
errno = 0;
int self_rc = dr_raw_replace(source, source);
int self_err = self_rc < 0 ? errno : 0;
int after = fcntl(source, F_GETFD);
dr_raw_cloexec(target, 1);
errno = 0;
int bind_rc = dr_raw_replace(source, target);
int bind_err = bind_rc < 0 ? errno : 0;
int target_flags = fcntl(target, F_GETFD);
ssize_t na = read(source, a, 2);
ssize_t nb = read(target, b, 3);
off_t pos = lseek(target, 0, SEEK_CUR);
errno = 0;
int bad_rc = dr_raw_replace(-1, target);
int bad_err = bad_rc < 0 ? errno : 0;
off_t preserved = lseek(target, 0, SEEK_CUR);
errno = 0;
int negative_rc = dr_raw_replace(source, -1);
int negative_err = negative_rc < 0 ? errno : 0;
errno = 0;
int closed_rc = dr_raw_replace(-1, -1);
int closed_err = closed_rc < 0 ? errno : 0;
errno = 0;
int invalid_rc = dr_raw_cloexec(source, 2);
int invalid_err = invalid_rc < 0 ? errno : 0;
errno = 0;
int invalid_fd_rc = dr_raw_cloexec(-1, 0);
int invalid_fd_err = invalid_fd_rc < 0 ? errno : 0;
errno = 0;
int clear_rc = dr_raw_cloexec(source, 0);
int clear_err = clear_rc < 0 ? errno : 0;
int clear_flags = fcntl(source, F_GETFD);
int vacant = dup(source);
close(vacant);
errno = 0;
int vacant_rc = dr_raw_replace(source, vacant);
int vacant_err = vacant_rc < 0 ? errno : 0;
int vacant_flags = fcntl(vacant, F_GETFD);
close(vacant);
printf("{\"source\":%d,\"target\":%d,\"flag_rc\":%d,\"flag_err\":%d,"
"\"before\":%d,\"self_rc\":%d,\"self_err\":%d,\"after\":%d,"
"\"bind_rc\":%d,\"bind_err\":%d,\"target_flags\":%d,"
"\"na\":%lld,\"nb\":%lld,\"a\":\"", source, target, flag_rc,
flag_err, before, self_rc, self_err, after, bind_rc, bind_err,
target_flags, (long long)na, (long long)nb);
if (na > 0 && na <= DR_LIMIT) hexprint(a, (size_t)na);
printf("\",\"b\":\"");
if (nb > 0 && nb <= DR_LIMIT) hexprint(b, (size_t)nb);
printf("\",\"pos\":%lld,\"bad_rc\":%d,\"bad_err\":%d,"
"\"preserved\":%lld,\"negative_rc\":%d,\"negative_err\":%d,"
"\"closed_rc\":%d,\"closed_err\":%d,\"invalid_rc\":%d,"
"\"invalid_err\":%d,\"invalid_fd_rc\":%d,\"invalid_fd_err\":%d,"
"\"clear_rc\":%d,\"clear_err\":%d,\"clear_flags\":%d}\n",
(long long)pos, bad_rc, bad_err, (long long)preserved, negative_rc,
negative_err, closed_rc, closed_err, invalid_rc, invalid_err,
invalid_fd_rc, invalid_fd_err, clear_rc, clear_err, clear_flags);
printf("{\"vacant\":%d,\"rc\":%d,\"err\":%d,\"flags\":%d}\n", vacant, vacant_rc, vacant_err, vacant_flags);
fclose(left);
fclose(right);
}
static void null_call(dr_bank *bank, const char *name)
{
long long result = -2;
unsigned char byte = 0;
dr_view view;
int value;
size_t size;
errno = 0;
if (!strcmp(name, "init")) { dr_init(NULL); result = 0; }
if (!strcmp(name, "reset")) result = dr_reset(NULL);
if (!strcmp(name, "seed_bank")) result = dr_seed(NULL, 0, &byte, 1, "a");
if (!strcmp(name, "seed_data")) result = dr_seed(bank, 0, NULL, 1, "a");
if (!strcmp(name, "seed_empty")) result = dr_seed(bank, 0, NULL, 0, "empty");
if (!strcmp(name, "seed_name")) result = dr_seed(bank, 0, &byte, 1, NULL);
if (!strcmp(name, "bind")) result = dr_bind(NULL, 0, 1);
if (!strcmp(name, "drop")) result = dr_drop(NULL, 0);
if (!strcmp(name, "take_bank")) result = dr_take(NULL, 0, &byte, 1);
if (!strcmp(name, "emit_bank")) result = dr_emit(NULL, 0, &byte, 1);
if (!strcmp(name, "seek")) result = dr_seek(NULL, 0, 0);
if (!strcmp(name, "flags")) result = dr_flags(NULL, 0, 0);
if (!strcmp(name, "inspect_bank")) result = dr_inspect(NULL, 0, &view);
if (!strcmp(name, "inspect_view")) result = dr_inspect(bank, 0, NULL);
if (!strcmp(name, "parse_text")) result = dr_parse_i32(NULL, &value);
if (!strcmp(name, "parse_value")) result = dr_parse_i32("1", NULL);
if (!strcmp(name, "decode_text")) result = dr_hex_decode(NULL, &byte, 1, &size);
if (!strcmp(name, "decode_length")) result = dr_hex_decode("00", &byte, 1, NULL);
if (!strcmp(name, "encode_output")) result = dr_hex_encode(&byte, 1, NULL, 3);
if (!strcmp(name, "encode_overflow")) result = dr_hex_encode(&byte, (size_t)-1, (char *)&view, 3);
if (!strcmp(name, "encode_data")) result = dr_hex_encode(NULL, 1, (char *)&view, 3);
status(result, errno);
}
int main(void)
{
dr_bank first, second;
dr_init(&first);
dr_init(&second);
dr_bank *bank = &first;
char *line = NULL;
size_t capacity = 0;
while (getline(&line, &capacity, stdin) >= 0) {
char *words[8];
int count = 0;
char *save = NULL;
for (char *p = strtok_r(line, " \t\r\n", &save); p && count < 8;
p = strtok_r(NULL, " \t\r\n", &save)) words[count++] = p;
if (!count) continue;
if (!strcmp(words[0], "use")) {
bank = atoi(words[1]) == 0 ? &first : &second;
status(0, 0);
continue;
}
unsigned char data[DR_LIMIT + 1];
int slot = count > 1 ? atoi(words[1]) : 0;
int other = count > 2 ? atoi(words[2]) : 0;
long long result = -1;
errno = 0;
if (!strcmp(words[0], "raw")) { raw(words[1]); continue; }
if (!strcmp(words[0], "null")) { null_call(bank, words[1]); continue; }
if (!strcmp(words[0], "parse")) {
size_t n = unhex(words[1], data);
data[n] = 0;
int value = 1234567;
int rc = dr_parse_i32((char *)data, &value);
printf("{\"rc\":%d,\"err\":%d,\"value\":%d}\n", rc, rc < 0 ? errno : 0, value);
continue;
}
if (!strcmp(words[0], "decodebig")) {
unsigned char output[DR_LIMIT + 1];
size_t length = 777;
memset(output, 0xa5, sizeof output);
int rc = dr_hex_decode(words[1], output, (size_t)other, &length);
printf("{\"rc\":%d,\"err\":%d,\"length\":%zu,\"buffer\":\"", rc, rc < 0 ? errno : 0, length);
hexprint(output, sizeof output);
printf("\"}\n");
continue;
}
if (!strcmp(words[0], "encodebig")) {
unsigned char output[DR_LIMIT * 2 + 2];
size_t length = unhex(words[1], data);
memset(output, 0xa5, sizeof output);
int rc = dr_hex_encode(data, length, (char *)output, (size_t)other);
printf("{\"rc\":%d,\"err\":%d,\"buffer\":\"", rc, rc < 0 ? errno : 0);
hexprint(output, sizeof output);
printf("\"}\n");
continue;
}
if (!strcmp(words[0], "decode")) {
unsigned char text[DR_LIMIT + 1], output[16];
size_t n = unhex(words[3], text), length = 777;
text[n] = 0;
memset(output, 0xa5, sizeof output);
int rc = dr_hex_decode((char *)text, other ? NULL : output, (size_t)slot, &length);
printf("{\"rc\":%d,\"err\":%d,\"length\":%zu,\"buffer\":\"", rc, rc < 0 ? errno : 0, length);
hexprint(output, sizeof output);
printf("\"}\n");
continue;
}
if (!strcmp(words[0], "encode")) {
unsigned char output[24];
size_t n = unhex(words[3], data);
memset(output, 0xa5, sizeof output);
int rc = dr_hex_encode(other ? NULL : data, n, (char *)output, (size_t)slot);
printf("{\"rc\":%d,\"err\":%d,\"buffer\":\"", rc, rc < 0 ? errno : 0);
hexprint(output, sizeof output);
printf("\"}\n");
continue;
}
if (!strcmp(words[0], "reset")) result = dr_reset(bank);
if (!strcmp(words[0], "seed")) {
size_t n = unhex(words[2], data);
result = dr_seed(bank, slot, data, n, words[3]);
}
if (!strcmp(words[0], "bind")) result = dr_bind(bank, slot, other);
if (!strcmp(words[0], "drop")) result = dr_drop(bank, slot);
if (!strcmp(words[0], "flags")) result = dr_flags(bank, slot, other);
if (!strcmp(words[0], "seek")) result = dr_seek(bank, slot, other);
if (!strcmp(words[0], "write")) {
size_t n = unhex(words[2], data);
result = dr_emit(bank, slot, data, n);
}
if (!strcmp(words[0], "readnull")) result = dr_take(bank, slot, NULL, (size_t)other);
if (!strcmp(words[0], "writenull")) result = dr_emit(bank, slot, NULL, (size_t)other);
if (!strcmp(words[0], "read")) {
result = dr_take(bank, slot, data, (size_t)other);
int error = result < 0 ? errno : 0;
printf("{\"rc\":%lld,\"err\":%d,\"data\":\"", result, error);
if (result > 0 && result <= DR_LIMIT) hexprint(data, (size_t)result);
printf("\"}\n");
continue;
}
if (!strcmp(words[0], "info")) {
dr_view view;
memset(&view, 0xa5, sizeof view);
result = dr_inspect(bank, slot, &view);
if (result == 0) {
printf("{\"rc\":0,\"err\":0,\"cursor\":%lld,\"size\":%lld,\"cloexec\":%d,"
"\"read_bytes\":%lu,\"written_bytes\":%lu,\"name\":\"%s\"}\n",
(long long)view.cursor, (long long)view.size, view.cloexec,
view.read_bytes, view.written_bytes, view.name);
continue;
}
}
status(result, errno);
}
free(line);
dr_reset(&first);
dr_reset(&second);
return 0;
}