1
0
mirror of https://passt.top/passt synced 2024-12-22 21:55:22 +00:00
passt/lineread.c
David Gibson dab2c6ee1f Add cleaner line-by-line reading primitives
Two places in passt need to read files line by line (one parsing
resolv.conf, the other parsing /proc/net/*.  They can't use fgets()
because in glibc that can allocate memory.  Instead they use an
implementation line_read() in util.c.  This has some problems:

 * It has two completely separate modes of operation, one buffering
   and one not, the relation between these and how they're activated
   is subtle and confusing
 * At least in non-buffered mode, it will mishandle an empty line,
   folding them onto the start of the next non-empty line
 * In non-buffered mode it will use lseek() which prevents using this
   on non-regular files (we don't need that at present, but it's a
   surprising limitation)
 * It has a lot of difficult to read pointer mangling

Add a new cleaner implementation of allocation-free line-by-line
reading in lineread.c.  This one always buffers, using a state
structure to keep track of what we need.  This is larger than I'd
like, but it turns out handling all the edge cases of line-by-line
reading in C is surprisingly hard.

This just adds the code, subsequent patches will change the existing
users of line_read() to the new implementation.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2022-07-06 08:10:55 +02:00

116 lines
2.7 KiB
C

// SPDX-License-Identifier: AGPL-3.0-or-later
/* PASST - Plug A Simple Socket Transport
* for qemu/UNIX domain socket mode
*
* PASTA - Pack A Subtle Tap Abstraction
* for network namespace/tap device mode
*
* lineread.c - Allocation free line-by-line buffered file input
*
* Copyright Red Hat
* Author: David Gibson <david@gibson.dropbear.id.au>
*/
#include <stddef.h>
#include <fcntl.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <unistd.h>
#include "lineread.h"
/**
* lineread_init() - Prepare for line by line file reading without allocation
* @lr: Line reader state structure to initialize
* @fd: File descriptor to read lines from
*/
void lineread_init(struct lineread *lr, int fd)
{
lr->fd = fd;
lr->next_line = lr->count = 0;
}
/**
* peek_line() - Find and NULL-terminate next line in buffer
* @lr: Line reader state structure
* @eof: Caller indicates end-of-file was already found by read()
*
* Return: length of line in bytes, -1 if no line was found
*/
static int peek_line(struct lineread *lr, bool eof)
{
char *nl;
/* Sanity checks (which also document invariants) */
assert(lr->count >= 0);
assert(lr->next_line >= 0);
assert(lr->next_line + lr->count >= lr->next_line);
assert(lr->next_line + lr->count <= LINEREAD_BUFFER_SIZE);
nl = memchr(lr->buf + lr->next_line, '\n', lr->count);
if (nl) {
*nl = '\0';
return nl - lr->buf - lr->next_line + 1;
}
if (eof) {
lr->buf[lr->next_line + lr->count] = '\0';
/* No trailing newline, so treat all remaining bytes
* as the last line
*/
return lr->count;
}
return -1;
}
/**
* lineread_get() - Read a single line from file (no allocation)
* @lr: Line reader state structure
* @line: Place a pointer to the next line in this variable
*
* Return: Length of line read on success, 0 on EOF, negative on error
*/
int lineread_get(struct lineread *lr, char **line)
{
bool eof = false;
int line_len;
while ((line_len = peek_line(lr, eof)) < 0) {
int rc;
if ((lr->next_line + lr->count) == LINEREAD_BUFFER_SIZE) {
/* No space at end */
if (lr->next_line == 0) {
/* Buffer is full, which means we've
* hit a line too long for us to
* process. FIXME: report error
* better
*/
return -1;
}
memmove(lr->buf, lr->buf + lr->next_line, lr->count);
lr->next_line = 0;
}
/* Read more data into the end of buffer */
rc = read(lr->fd, lr->buf + lr->next_line + lr->count,
LINEREAD_BUFFER_SIZE - lr->next_line - lr->count);
if (rc < 0)
return rc;
if (rc == 0)
eof = true;
else
lr->count += rc;
}
*line = lr->buf + lr->next_line;
lr->next_line += line_len;
lr->count -= line_len;
return line_len;
}