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>
268 lines
11 KiB
C
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;
|
|
}
|