Vox/vlibc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(stdio): getline/getdelim/stream locking

Browse Source
This commit is contained in:
huntedbytheirs
2026-09-05 17:18:18 -04:00
parent 14c6fd6cf6
commit a2f7c33601
7 changed files with 1625 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_getline.c
+611
View File
@@ -0,0 +1,611 @@
/*
* vlibc — getline/getdelim, stream locking, memory streams test (todo 18).
*
* Exercises the todo-18 additions end to end:
*
* 1. getline on a 1 MiB line returns 1000001 (delimiter included) with a
* NUL terminator, growing a NULL/zero-capacity buffer from scratch;
* the next call at end of file returns -1. Reuse keeps the grown
* buffer.
* 2. getdelim with ',' over "a,b,c\n" yields "a,", "b,", then the
* partial final field "c\n" at end of file, then -1.
* 3. Embedded NUL bytes survive: getline on "ab\0cd\n" returns 6 with
* the NUL at line[2] intact (length, not strlen).
* 4. A small preallocated buffer (malloc(4)) grows to fit a long line.
* 5. flockfile recursion: two nested flockfile calls, ftrylockfile
* failing (nonzero) under the recursion and succeeding (0) when the
* stream is free again.
* 6. getc_unlocked/putc_unlocked under a held flockfile move real data;
* getchar_unlocked/putchar_unlocked and puts work over freopen'd
* stdin/stdout.
* 7. fmemopen over a fixed buffer: write, rewind, read back
* byte-identical; seeking past the size reads EOF (no error);
* fmemopen(NULL, ...) grows and is freed by fclose (leak-checked);
* "a" starts at the current data length.
* 8. open_memstream: after fflush/fclose *sizeloc is the length and the
* buffer is NUL-terminated; *ptr tracks the (possibly moved) buffer.
* 9. fclose over many fmemopen/open_memstream cycles leaks nothing.
*
* Failure mode (-f): getline on a stream whose underlying descriptor was
* closed underneath it returns -1 (the read hits EBADF); the return value
* is asserted, never errno. -f exits via a raw SYS_exit_group before any
* host-libc cleanup runs (the tests/syscall_test.c discipline).
*
* errno is never READ here; the default mode keeps every library errno
* write out of the exercised paths. All diagnostics go through raw
* SYS_write and the only headers are vlibc's own.
*
* Not part of the library proper; compiled manually for this todo.
*/
#include <stdio.h>
#include <stdlib.h>
#include "../src/internal/syscall.h"
/* The allocator's heap-walk consistency probe (hidden; linked in via
* malloc.c). Returns the live block count, or (size_t)-1 on disagreement. */
extern size_t
__vlibc_malloc_check(void); // NOLINT(bugprone-reserved-identifier)
static int failures;
/* Write a NUL-terminated string to fd via the raw syscall layer. */
static void
say(int fd, const char *s)
{
long n = 0;
while (s[n] != '\0')
{
n++;
}
__syscall3(SYS_write, fd, (long)s, n);
}
/* Write v in decimal to fd. */
static void
say_dec(int fd, unsigned long v) // NOLINT(bugprone-easily-swappable-parameters)
{
char buf[24];
int i = (int)sizeof(buf);
buf[--i] = '\0';
do
{
buf[--i] = (char)('0' + (v % 10));
v /= 10;
} while (v != 0);
__syscall3(SYS_write, fd, (long)(buf + i), (long)(sizeof(buf) - 1 - i));
}
static void
check(int cond, const char *what)
{
if (cond)
{
say(1, "PASS: ");
say(1, what);
say(1, "\n");
}
else
{
say(2, "FAIL: ");
say(2, what);
say(2, "\n");
failures++;
}
}
/* Byte-compare two buffers. noipa keeps -O2 from folding the check. */
// NOLINTBEGIN(clang-analyzer-unix.Stream)
static __attribute__((noipa)) int
mem_eq(const unsigned char *a, const unsigned char *b, unsigned long n)
{
unsigned long i;
for (i = 0; i < n; i++)
{
if (a[i] != b[i])
{
return 0;
}
}
return 1;
}
/* Byte-compare two NUL-terminated strings. */
static __attribute__((noipa)) int
str_eq(const char *a, const char *b)
{
while (*a == *b && *a != '\0')
{
a++;
b++;
}
return *a == *b;
}
/* Read a whole small file through raw syscalls into buf; returns size. */
static long
raw_read_all(const char *path, char *buf, unsigned long cap)
{
long fd = __syscall4(SYS_openat, -100, (long)path, 0x0, 0);
long got = -1;
long total = 0;
if (fd < 0)
{
return -1;
}
while (total < (long)cap)
{
got = __syscall3(SYS_read, fd, (long)(buf + total), (long)(cap - (unsigned long)total));
if (got <= 0)
{
break;
}
total += got;
}
__syscall1(SYS_close, fd);
return got < 0 ? -1 : total;
}
/* Write path bytes to a fresh file, then reopen it for reading. */
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
static FILE *
write_file(const char *path, const char *data, unsigned long n)
{
FILE *f = fopen(path, "w");
if (f == NULL)
{
return NULL;
}
if (fwrite(data, 1, n, f) != n)
{
(void)fclose(f);
return NULL;
}
if (fclose(f) != 0)
{
return NULL;
}
f = fopen(path, "r");
if (f == NULL)
{
say(2, "FAIL: write_file reopen\n");
failures++;
}
return f;
}
// NOLINTEND(bugprone-easily-swappable-parameters)
static char onemeg[1000001];
/* 1/3/4: getline length, growth, EOF, embedded NUL. */
static void
line_scenario(void)
{
const char bigpath[] = "/tmp/vlibc-test-t18-bigline.txt";
const char nulpath[] = "/tmp/vlibc-test-t18-nul.txt";
const char longpath[] = "/tmp/vlibc-test-t18-long.txt";
const char longline[] = "this line is way longer than sixteen bytes\n";
FILE *f;
char *line;
size_t n;
ssize_t got;
unsigned long i;
for (i = 0; i < 1000000; i++)
{
onemeg[i] = 'x';
}
onemeg[1000000] = '\n';
f = fopen(bigpath, "w");
check(f != NULL, "bigline fopen w succeeds");
if (f == NULL)
{
return;
}
check(fwrite(onemeg, 1, sizeof(onemeg), f) == sizeof(onemeg), "bigline fwrite 1 MiB + newline");
check(fclose(f) == 0, "bigline fclose writer");
f = fopen(bigpath, "r");
check(f != NULL, "bigline fopen r succeeds");
line = NULL;
n = 0;
got = getline(&line, &n, f);
check(got == 1000001, "getline on the 1 MiB line returns 1000001");
check(line != NULL && n >= 1000002, "getline grew the buffer past 1 MiB + NUL");
if (line != NULL)
{
int allx = 1;
for (i = 0; i < 1000000; i++)
{
if (line[i] != 'x')
{
allx = 0;
break;
}
}
check(allx != 0, "the 1 MiB line content is intact");
check(line[1000000] == '\n', "the newline is kept at line[1000000]");
check(line[1000001] == '\0', "the line is NUL-terminated");
}
got = getline(&line, &n, f);
check(got == -1, "getline at end of file returns -1");
free(line);
check(fclose(f) == 0, "bigline fclose reader");
check(remove(bigpath) == 0, "bigline remove");
/* Embedded NUL bytes are data, not terminators. */
f = write_file(nulpath, "ab\0cd\n", 6);
if (f != NULL)
{
line = NULL;
n = 0;
got = getline(&line, &n, f);
check(got == 6, "getline over \"ab\\0cd\\n\" returns 6 bytes");
check(line != NULL && line[0] == 'a' && line[1] == 'b' && line[2] == '\0' &&
line[3] == 'c' && line[4] == 'd' && line[5] == '\n' && line[6] == '\0',
"embedded NUL survives and the line is still NUL-terminated");
free(line);
check(fclose(f) == 0, "nul fclose");
check(remove(nulpath) == 0, "nul remove");
}
/* A small preallocated buffer grows past its initial capacity. */
f = write_file(longpath, longline, sizeof(longline) - 1);
if (f != NULL)
{
line = malloc(4);
check(line != NULL, "small-buffer malloc");
n = 4;
got = getline(&line, &n, f);
check(got == (ssize_t)(sizeof(longline) - 1),
"getline with a 4-byte buffer reads the whole long line");
check(n > sizeof(longline) - 1, "the capacity grew past the line length");
check(line != NULL && str_eq(line, longline), "grown small buffer holds the line");
free(line);
check(fclose(f) == 0, "long fclose");
check(remove(longpath) == 0, "long remove");
}
}
/* 2: getdelim with a custom delimiter. */
static void
delim_scenario(void)
{
const char path[] = "/tmp/vlibc-test-t18-delim.txt";
FILE *f;
char *line;
size_t n;
ssize_t got;
f = write_file(path, "a,b,c\n", 6);
check(f != NULL, "delim file setup");
if (f == NULL)
{
return;
}
line = NULL;
n = 0;
got = getdelim(&line, &n, ',', f);
check(got == 2 && line != NULL && str_eq(line, "a,"), "getdelim first field is \"a,\"");
got = getdelim(&line, &n, ',', f);
check(got == 2 && line != NULL && str_eq(line, "b,"), "getdelim second field is \"b,\"");
got = getdelim(&line, &n, ',', f);
check(got == 2 && line != NULL && str_eq(line, "c\n"),
"getdelim returns the partial final field at end of file");
got = getdelim(&line, &n, ',', f);
check(got == -1, "getdelim at end of file returns -1");
free(line);
check(fclose(f) == 0, "delim fclose");
check(remove(path) == 0, "delim remove");
}
/* 5/6: stream locking and the four _unlocked forms. */
static void
lock_scenario(void)
{
const char rpath[] = "/tmp/vlibc-test-t18-lockr.txt";
const char wpath[] = "/tmp/vlibc-test-t18-lockw.txt";
char got[8];
FILE *f;
int r0;
int r1;
f = fopen(rpath, "w+");
check(f != NULL, "lock fopen w+ succeeds");
if (f == NULL)
{
return;
}
r0 = ftrylockfile(f);
check(r0 == 0, "ftrylockfile on a free stream returns 0");
flockfile(f); /* recursion depth 2 */
flockfile(f); /* recursion depth 3 */
r1 = ftrylockfile(f);
check(r1 != 0, "ftrylockfile under the recursion returns nonzero");
funlockfile(f);
funlockfile(f);
funlockfile(f);
r0 = ftrylockfile(f);
check(r0 == 0, "ftrylockfile succeeds again after all unlocks");
funlockfile(f);
check(fclose(f) == 0, "lock fclose");
f = write_file(rpath, "MNO", 3);
check(f != NULL, "unlocked-read setup");
if (f != NULL)
{
flockfile(f);
check(getc_unlocked(f) == 'M', "getc_unlocked reads 'M' under the lock");
check(getc_unlocked(f) == 'N', "getc_unlocked reads 'N' under the lock");
funlockfile(f);
check(fgetc(f) == 'O', "the locked fgetc still reads 'O' after unlock");
check(fclose(f) == 0, "unlocked-read fclose");
check(remove(rpath) == 0, "unlocked-read remove");
}
f = fopen(wpath, "w");
check(f != NULL, "unlocked-write setup");
if (f != NULL)
{
flockfile(f);
check(putc_unlocked('Q', f) == 'Q', "putc_unlocked writes 'Q' under the lock");
check(putc_unlocked('R', f) == 'R', "putc_unlocked writes 'R' under the lock");
funlockfile(f);
check(fclose(f) == 0, "unlocked-write fclose");
check(raw_read_all(wpath, got, sizeof(got)) == 2 && got[0] == 'Q' && got[1] == 'R',
"putc_unlocked data reached the file");
check(remove(wpath) == 0, "unlocked-write remove");
}
}
/* 7: fmemopen over a fixed buffer, past-size EOF, NULL-buffer growth, 'a'. */
static void
fmemopen_scenario(void)
{
char buf[64];
char out[64];
FILE *f;
size_t r;
int c;
f = fmemopen(buf, sizeof(buf), "w+");
check(f != NULL, "fmemopen w+ succeeds");
if (f == NULL)
{
return;
}
check(fputs("hello fmemopen", f) >= 0, "fputs into the fixed buffer");
check(ftello(f) == 14, "ftello == 14 after the write");
check(fseek(f, 0, SEEK_SET) == 0, "rewind via fseek(0, SEEK_SET)");
r = fread(out, 1, sizeof(out), f);
check(r == 14 &&
mem_eq((const unsigned char *)out, (const unsigned char *)"hello fmemopen", 14),
"fmemopen write/rewind/read is byte-identical");
c = fgetc(f);
check(c == EOF && feof(f), "fmemopen read past the data returns EOF");
check(fclose(f) == 0, "fmemopen w+ fclose");
/* Seek beyond the buffer size, then read: EOF, not an error. */
f = fmemopen(buf, sizeof(buf), "w+");
if (f != NULL)
{
check(fputs("xyz", f) >= 0, "fmemopen setup writes xyz");
check(fseek(f, 100, SEEK_SET) == 0, "fseek past the size succeeds");
c = fgetc(f);
check(c == EOF && feof(f) && ferror(f) == 0, "reading past the size is EOF with no error");
check(ftello(f) == 100, "ftello stays at the seek target");
check(fclose(f) == 0, "fmemopen past-size fclose");
}
/* 'a' positions and appends at the current data length. */
{
char abuf[64] = "hello";
FILE *g = fmemopen(abuf, sizeof(abuf), "a");
check(g != NULL, "fmemopen a succeeds");
if (g != NULL)
{
check(ftello(g) == 5, "fmemopen a starts at the current length");
check(fputs("XY", g) >= 0, "fmemopen a appends");
check(fclose(g) == 0, "fmemopen a fclose flushes");
check(mem_eq((const unsigned char *)abuf, (const unsigned char *)"helloXY", 7),
"the appended data landed in the caller buffer");
check(abuf[7] == '\0', "string-mode fmemopen NUL-terminates at the length");
}
}
}
/* open_memstream: publish on flush, grow, NUL-terminate, free on close. */
static void
memstream_scenario(void)
{
char *p = NULL;
size_t z = 0;
FILE *f;
f = open_memstream(&p, &z);
check(f != NULL && p != NULL && z == 0, "open_memstream returns a stream and an empty buffer");
if (f == NULL)
{
return;
}
check(fputs("hello", f) >= 0, "open_memstream write 1");
check(fflush(f) == 0, "open_memstream fflush 1");
check(z == 5, "*sizeloc is the length after fflush");
check(p != NULL && p[5] == '\0' &&
mem_eq((const unsigned char *)p, (const unsigned char *)"hello", 5),
"the flushed buffer is NUL-terminated at the length");
check(fputs(" world", f) >= 0, "open_memstream write 2");
check(fflush(f) == 0, "open_memstream fflush 2");
check(z == 11 && p != NULL && p[11] == '\0',
"the grown length and NUL are published after the second fflush");
check(fclose(f) == 0, "open_memstream fclose");
check(z == 11 && p != NULL && p[11] == '\0', "fclose keeps the NUL-terminated result");
check(mem_eq((const unsigned char *)p, (const unsigned char *)"hello world", 11),
"the open_memstream content is correct");
free(p);
}
/* 9: no leaks across repeated memory-stream open/close cycles. */
static void
memstream_leak_scenario(void)
{
const char *data = "0123456789abcdef0123456789abcdef0123456789abcdef";
size_t before;
size_t after;
int i;
before = __vlibc_malloc_check();
check(before != (size_t)-1, "allocator heap walk is consistent before the cycles");
if (before == (size_t)-1)
{
return;
}
for (i = 0; i < 100; i++)
{
FILE *g;
char *p = NULL;
size_t z = 0;
g = fmemopen(NULL, 8, "w");
if (g == NULL || fputs(data, g) == EOF || fclose(g) != 0)
{
say(2, "FAIL: fmemopen cycle failed\n");
failures++;
return;
}
g = open_memstream(&p, &z);
if (g == NULL || fputs(data, g) == EOF || fclose(g) != 0)
{
say(2, "FAIL: open_memstream cycle failed\n");
failures++;
return;
}
free(p);
}
after = __vlibc_malloc_check();
check(after == before,
"fclose releases memory-stream FILEs and owned buffers (no leak over 100 cycles)");
}
/* puts, putchar_unlocked, getchar_unlocked over redirected std streams. */
static void
stream_redirect_scenario(void)
{
const char outpath[] = "/tmp/vlibc-test-t18-stdout.txt";
const char inpath[] = "/tmp/vlibc-test-t18-stdin.txt";
char buf[32];
long saved_out;
long saved_in;
long got;
int r1;
int r2;
int r3;
int r4;
int c;
/* stdout: no check() output on fd 1 while it names the file. */
saved_out = __syscall1(SYS_dup, 1);
check(saved_out >= 0, "dup(1) saves the stdout descriptor");
r1 = (freopen(outpath, "w", stdout) == stdout);
r2 = (puts("AA") >= 0);
r3 = (putchar_unlocked('B') == 'B');
r4 = (fflush(stdout) == 0);
__syscall2(SYS_dup2, saved_out, 1);
__syscall1(SYS_close, saved_out);
check(r1, "freopen stdout to a file");
check(r2, "puts writes through stdout");
check(r3, "putchar_unlocked writes through stdout");
check(r4, "fflush(stdout) after the freopen");
got = raw_read_all(outpath, buf, sizeof(buf));
check(got == 4 && buf[0] == 'A' && buf[1] == 'A' && buf[2] == '\n' && buf[3] == 'B',
"puts + putchar_unlocked content reached the file as \"AA\\nB\"");
check(remove(outpath) == 0, "remove the stdout file");
/* stdin: seed a file, rebind stdin, read a char, restore. */
{
FILE *seed = write_file(inpath, "K", 1);
check(seed != NULL, "stdin seed file written");
if (seed != NULL)
{
(void)fclose(seed);
}
saved_in = __syscall1(SYS_dup, 0);
check(saved_in >= 0, "dup(0) saves the stdin descriptor");
r1 = (freopen(inpath, "r", stdin) == stdin);
c = getchar_unlocked();
r2 = (c == 'K');
__syscall2(SYS_dup2, saved_in, 0);
__syscall1(SYS_close, saved_in);
check(r1, "freopen stdin from the seed file");
check(r2, "getchar_unlocked reads the seed character");
check(remove(inpath) == 0, "remove the stdin file");
}
}
/* Failure scenarios (-f). */
static int
failure_scenarios(void)
{
const char path[] = "/tmp/vlibc-test-t18-fail.txt";
FILE *f;
char *line = NULL;
size_t n = 0;
ssize_t got;
f = fopen(path, "w+");
if (f == NULL)
{
say(2, "FAIL: -f setup fopen failed\n");
failures++;
return 1;
}
check(fputs("data-data-data", f) >= 0, "-f setup fputs");
check(fflush(f) == 0, "-f setup fflush");
(void)__syscall1(SYS_close, fileno(f)); /* close the fd underneath */
got = getline(&line, &n, f);
check(got == -1, "getline on a closed-underneath stream returns -1");
free(line);
(void)fclose(f);
check(remove(path) == 0, "-f remove");
return failures > 0 ? 1 : 0;
}
// NOLINTEND(clang-analyzer-unix.Stream)
int
main(int argc, char **argv)
{
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
{
int rc = failure_scenarios();
__syscall1(SYS_exit_group, rc);
return rc; /* not reached */
}
line_scenario();
delim_scenario();
lock_scenario();
fmemopen_scenario();
memstream_scenario();
memstream_leak_scenario();
stream_redirect_scenario();
if (failures > 0)
{
say(2, "FAILED (");
say_dec(2, (unsigned long)failures);
say(2, " check(s))\n");
return 1;
}
say(1, "all getline/locking/memstream tests passed\n");
return 0;
}