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>

3 files changed, 150 insertions, 4 deletions

diff --git a/Makefile b/Makefile
index d2e25b4..c441af3 100644
--- a/Makefile
+++ b/Makefile
@@ -32,16 +32,16 @@ CFLAGS += -DRLIMIT_STACK_VAL=$(RLIMIT_STACK_VAL)
 CFLAGS += -DARCH=\"$(TARGET_ARCH)\"
 
 PASST_SRCS = arch.c arp.c checksum.c conf.c dhcp.c dhcpv6.c icmp.c igmp.c \
-	mld.c ndp.c netlink.c packet.c passt.c pasta.c pcap.c siphash.c \
-	tap.c tcp.c tcp_splice.c udp.c util.c
+	lineread.c mld.c ndp.c netlink.c packet.c passt.c pasta.c pcap.c \
+	siphash.c tap.c tcp.c tcp_splice.c udp.c util.c
 QRAP_SRCS = qrap.c
 SRCS = $(PASST_SRCS) $(QRAP_SRCS)
 
 MANPAGES = passt.1 pasta.1 qrap.1
 
 PASST_HEADERS = arch.h arp.h checksum.h conf.h dhcp.h dhcpv6.h icmp.h \
-	ndp.h netlink.h packet.h passt.h pasta.h pcap.h siphash.h \
-	tap.h tcp.h tcp_splice.h udp.h util.h
+	lineread.h ndp.h netlink.h packet.h passt.h pasta.h pcap.h \
+	siphash.h tap.h tcp.h tcp_splice.h udp.h util.h
 HEADERS = $(PASST_HEADERS)
 
 # On gcc 11.2, with -O2 and -flto, tcp_hash() and siphash_20b(), if inlined,
diff --git a/lineread.c b/lineread.c
new file mode 100644
index 0000000..59021e6
--- /dev/null
+++ b/lineread.c
@@ -0,0 +1,115 @@
+// 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;
+}
diff --git a/lineread.h b/lineread.h
new file mode 100644
index 0000000..b6faff5
--- /dev/null
+++ b/lineread.h
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: AGPL-3.0-or-later
+ * Copyright Red Hat
+ * Author: David Gibson <david@gibson.dropbear.id.au>
+ */
+
+#ifndef LINEREAD_H
+#define LINEREAD_H
+
+#define LINEREAD_BUFFER_SIZE	8192
+
+/**
+ * struct lineread - Line reader state
+ * @fd:		File descriptor lines are read from
+ * @next_line:	Offset in @buf of the start of the first line not yet
+ *		returned by lineread_get()
+ * @count:	Number of bytes in @buf read from the file, but not yet
+ *		returned by lineread_get()
+ * @buf:	Buffer storing data read from file.
+ */
+struct lineread {
+	int fd; int next_line;
+	int count;
+
+	/* One extra byte for possible trailing \0 */
+	char buf[LINEREAD_BUFFER_SIZE+1];
+};
+
+void lineread_init(struct lineread *lr, int fd);
+int lineread_get(struct lineread *lr, char **line);
+
+#endif /* _LINEREAD_H */