aboutsummaryrefslogtreecommitdiffstats
path: root/libio/readline.c
diff options
context:
space:
mode:
authorFlorian Weimer <fweimer@redhat.com>2018-07-06 16:53:48 +0200
committerFlorian Weimer <fweimer@redhat.com>2018-07-06 17:52:54 +0200
commit3f5e3f5d066dcffb80af48ae2cf35a01a85a8f10 (patch)
tree2eb99509fbdfb5f61ee40bdf634c63f092b85ae2 /libio/readline.c
parent397c54c1afa531242602fe3ac7bb47eff0e909f9 (diff)
downloadtermbaud-3f5e3f5d066dcffb80af48ae2cf35a01a85a8f10.tar.gz
termbaud-3f5e3f5d066dcffb80af48ae2cf35a01a85a8f10.tar.xz
termbaud-3f5e3f5d066dcffb80af48ae2cf35a01a85a8f10.zip
libio: Implement internal function __libc_readline_unlocked
This is a variant of fgets which fails with ERANGE if the buffer is too small, and the buffer length is given as an argument of type size_t. This function will be useful for implementing NSS file reading operations. Compared to a direct implementation using the public API, it avoids an lseek system call in case the line terminator can be found in the internal read buffer.
Diffstat (limited to 'libio/readline.c')
-rw-r--r--libio/readline.c170
1 files changed, 170 insertions, 0 deletions
diff --git a/libio/readline.c b/libio/readline.c
new file mode 100644
index 00000000000..36384591763
--- /dev/null
+++ b/libio/readline.c
@@ -0,0 +1,170 @@
+/* fgets with ERANGE error reporting and size_t buffer length.
+ Copyright (C) 2017 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libioP.h"
+
+/* Return -1 and set errno to EINVAL if it is ERANGE. */
+static ssize_t
+fail_no_erange (void)
+{
+ if (errno == ERANGE)
+ __set_errno (EINVAL);
+ return -1;
+}
+
+/* Slow path for reading the line. Called with no data in the stream
+ read buffer. Write data to [BUFFER, BUFFER_END). */
+static ssize_t
+readline_slow (FILE *fp, char *buffer, char *buffer_end)
+{
+ char *start = buffer;
+
+ while (buffer < buffer_end)
+ {
+ if (__underflow (fp) == EOF)
+ {
+ if (_IO_ferror_unlocked (fp))
+ /* If the EOF was caused by a read error, report it. */
+ return fail_no_erange ();
+ *buffer = '\0';
+ /* Do not include the null terminator. */
+ return buffer - start;
+ }
+
+ /* __underflow has filled the buffer. */
+ char *readptr = fp->_IO_read_ptr;
+ ssize_t readlen = fp->_IO_read_end - readptr;
+ /* Make sure that __underflow really has acquired some data. */
+ assert (readlen > 0);
+ char *pnl = memchr (readptr, '\n', readlen);
+ if (pnl != NULL)
+ {
+ /* We found the terminator. */
+ size_t line_length = pnl - readptr;
+ if (line_length + 2 > buffer_end - buffer)
+ /* Not enough room in the caller-supplied buffer. */
+ break;
+ memcpy (buffer, readptr, line_length + 1);
+ buffer[line_length + 1] = '\0';
+ fp->_IO_read_ptr = pnl + 1;
+ /* Do not include the null terminator. */
+ return buffer - start + line_length + 1;
+ }
+
+ if (readlen >= buffer_end - buffer)
+ /* Not enough room in the caller-supplied buffer. */
+ break;
+
+ /* Save and consume the stream buffer. */
+ memcpy (buffer, readptr, readlen);
+ fp->_IO_read_ptr = fp->_IO_read_end;
+ buffer += readlen;
+ }
+
+ /* The line does not fit into the buffer. */
+ __set_errno (ERANGE);
+ return -1;
+}
+
+ssize_t
+__libc_readline_unlocked (FILE *fp, char *buffer, size_t buffer_length)
+{
+ char *buffer_end = buffer + buffer_length;
+
+ /* Orient the stream. */
+ if (__builtin_expect (fp->_mode, -1) == 0)
+ _IO_fwide (fp, -1);
+
+ /* Fast path: The line terminator is found in the buffer. */
+ char *readptr = fp->_IO_read_ptr;
+ ssize_t readlen = fp->_IO_read_end - readptr;
+ off64_t start_offset; /* File offset before reading anything. */
+ if (readlen > 0)
+ {
+ char *pnl = memchr (readptr, '\n', readlen);
+ if (pnl != NULL)
+ {
+ size_t line_length = pnl - readptr;
+ /* Account for line and null terminators. */
+ if (line_length + 2 > buffer_length)
+ {
+ __set_errno (ERANGE);
+ return -1;
+ }
+ memcpy (buffer, readptr, line_length + 1);
+ buffer[line_length + 1] = '\0';
+ /* Consume the entire line. */
+ fp->_IO_read_ptr = pnl + 1;
+ return line_length + 1;
+ }
+
+ /* If the buffer does not have enough space for what is pending
+ in the stream (plus a NUL terminator), the buffer is too
+ small. */
+ if (readlen + 1 > buffer_length)
+ {
+ __set_errno (ERANGE);
+ return -1;
+ }
+
+ /* End of line not found. We need all the buffered data. Fall
+ through to the slow path. */
+ memcpy (buffer, readptr, readlen);
+ buffer += readlen;
+ /* The original length is invalid after this point. Use
+ buffer_end instead. */
+#pragma GCC poison buffer_length
+ /* Read the old offset before updating the read pointer. */
+ start_offset = __ftello64 (fp);
+ fp->_IO_read_ptr = fp->_IO_read_end;
+ }
+ else
+ {
+ readlen = 0;
+ start_offset = __ftello64 (fp);
+ }
+
+ /* Slow path: Read more data from the underlying file. We need to
+ restore the file pointer if the buffer is too small. First,
+ check if the __ftello64 call above failed. */
+ if (start_offset < 0)
+ return fail_no_erange ();
+
+ ssize_t result = readline_slow (fp, buffer, buffer_end);
+ if (result < 0)
+ {
+ if (errno == ERANGE)
+ {
+ /* Restore the file pointer so that the caller may read the
+ same line again. */
+ if (__fseeko64 (fp, start_offset, SEEK_SET) < 0)
+ return fail_no_erange ();
+ __set_errno (ERANGE);
+ }
+ /* Do not restore the file position on other errors; it is
+ likely that the __fseeko64 call would fail, too. */
+ return -1;
+ }
+ return readlen + result;
+}
+libc_hidden_def (__libc_readline_unlocked)