/* getndelim2 - Read a line from a stream, stopping at one of 2 delimiters,
with bounded memory allocation.
- Copyright (C) 1993, 1996, 1997, 1998, 2000, 2003 Free Software
- Foundation, Inc.
+ Copyright (C) 1993, 1996, 1997, 1998, 2000, 2003, 2004, 2006, 2008 Free
+ Software Foundation, Inc.
- This program is free software; you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software Foundation,
- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Originally written by Jan Brittenson, bson@gnu.ai.mit.edu. */
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
+#include <config.h>
-/* Specification. */
#include "getndelim2.h"
+#include <stdbool.h>
+#include <stddef.h>
#include <stdlib.h>
+#include <string.h>
+
+#if USE_UNLOCKED_IO
+# include "unlocked-io.h"
+#endif
+#if !HAVE_FLOCKFILE
+# undef flockfile
+# define flockfile(x) ((void) 0)
+#endif
+#if !HAVE_FUNLOCKFILE
+# undef funlockfile
+# define funlockfile(x) ((void) 0)
+#endif
-#include "unlocked-io.h"
+#include <limits.h>
+#include <stdint.h>
-/* Always add at least this many bytes when extending the buffer. */
+#include "freadptr.h"
+#include "freadseek.h"
+#include "memchr2.h"
+
+#ifndef SSIZE_MAX
+# define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
+#endif
+
+/* Use this to suppress gcc's `...may be used before initialized' warnings. */
+#ifdef lint
+# define IF_LINT(Code) Code
+#else
+# define IF_LINT(Code) /* empty */
+#endif
+
+/* The maximum value that getndelim2 can return without suffering from
+ overflow problems, either internally (because of pointer
+ subtraction overflow) or due to the API (because of ssize_t). */
+#define GETNDELIM2_MAXIMUM (PTRDIFF_MAX < SSIZE_MAX ? PTRDIFF_MAX : SSIZE_MAX)
+
+/* Try to add at least this many bytes when extending the buffer.
+ MIN_CHUNK must be no greater than GETNDELIM2_MAXIMUM. */
#define MIN_CHUNK 64
ssize_t
-getndelim2 (char **lineptr, size_t *linesize, size_t nmax,
- FILE *stream, int delim1, int delim2, size_t offset)
+getndelim2 (char **lineptr, size_t *linesize, size_t offset, size_t nmax,
+ int delim1, int delim2, FILE *stream)
{
- size_t nbytes_avail; /* Allocated but unused chars in *LINEPTR. */
+ size_t nbytes_avail; /* Allocated but unused bytes in *LINEPTR. */
char *read_pos; /* Where we're reading into *LINEPTR. */
+ ssize_t bytes_stored = -1;
+ char *ptr = *lineptr;
+ size_t size = *linesize;
+ bool found_delimiter;
- if (!lineptr || !linesize || !nmax || !stream)
- return -1;
-
- if (!*lineptr)
+ if (!ptr)
{
- size_t newlinesize = MIN_CHUNK;
-
- if (newlinesize > nmax)
- newlinesize = nmax;
-
- *linesize = newlinesize;
- *lineptr = malloc (*linesize);
- if (!*lineptr)
+ size = nmax < MIN_CHUNK ? nmax : MIN_CHUNK;
+ ptr = malloc (size);
+ if (!ptr)
return -1;
}
- if (*linesize < offset)
- return -1;
+ if (size < offset)
+ goto done;
- nbytes_avail = *linesize - offset;
- read_pos = *lineptr + offset;
+ nbytes_avail = size - offset;
+ read_pos = ptr + offset;
- if (nbytes_avail == 0 && *linesize >= nmax)
- return -1;
+ if (nbytes_avail == 0 && nmax <= size)
+ goto done;
- for (;;)
- {
- /* Here always *lineptr + *linesize == read_pos + nbytes_avail. */
+ /* Normalize delimiters, since memchr2 doesn't handle EOF. */
+ if (delim1 == EOF)
+ delim1 = delim2;
+ else if (delim2 == EOF)
+ delim2 = delim1;
- register int c;
+ flockfile (stream);
- /* We always want at least one char left in the buffer, since we
- always (unless we get an error while reading the first char)
- NUL-terminate the line buffer. */
+ found_delimiter = false;
+ do
+ {
+ /* Here always ptr + size == read_pos + nbytes_avail.
+ Also nbytes_avail > 0 || size < nmax. */
- if (nbytes_avail < 2 && *linesize < nmax)
+ int c IF_LINT (= 0);
+ const char *buffer;
+ size_t buffer_len;
+
+ buffer = freadptr (stream, &buffer_len);
+ if (buffer)
+ {
+ if (delim1 != EOF)
+ {
+ const char *end = memchr2 (buffer, delim1, delim2, buffer_len);
+ if (end)
+ {
+ buffer_len = end - buffer + 1;
+ found_delimiter = true;
+ }
+ }
+ }
+ else
{
- size_t newlinesize =
- (*linesize > MIN_CHUNK ? 2 * *linesize : *linesize + MIN_CHUNK);
+ c = getc (stream);
+ if (c == EOF)
+ {
+ /* Return partial line, if any. */
+ if (read_pos == ptr)
+ goto unlock_done;
+ else
+ break;
+ }
+ if (c == delim1 || c == delim2)
+ found_delimiter = true;
+ buffer_len = 1;
+ }
- if (newlinesize > nmax)
- newlinesize = nmax;
+ /* We always want at least one byte left in the buffer, since we
+ always (unless we get an error while reading the first byte)
+ NUL-terminate the line buffer. */
- if (newlinesize > *linesize)
+ if (nbytes_avail < buffer_len + 1 && size < nmax)
+ {
+ /* Grow size proportionally, not linearly, to avoid O(n^2)
+ running time. */
+ size_t newsize = size < MIN_CHUNK ? size + MIN_CHUNK : 2 * size;
+ char *newptr;
+
+ /* Increase newsize so that it becomes
+ >= (read_pos - ptr) + buffer_len. */
+ if (newsize - (read_pos - ptr) < buffer_len + 1)
+ newsize = (read_pos - ptr) + buffer_len + 1;
+ /* Respect nmax. This handles possible integer overflow. */
+ if (! (size < newsize && newsize <= nmax))
+ newsize = nmax;
+
+ if (GETNDELIM2_MAXIMUM < newsize - offset)
{
- *linesize = newlinesize;
- nbytes_avail = *linesize + *lineptr - read_pos;
- *lineptr = realloc (*lineptr, *linesize);
- if (!*lineptr)
- return -1;
- read_pos = *linesize - nbytes_avail + *lineptr;
+ size_t newsizemax = offset + GETNDELIM2_MAXIMUM + 1;
+ if (size == newsizemax)
+ goto unlock_done;
+ newsize = newsizemax;
}
+
+ nbytes_avail = newsize - (read_pos - ptr);
+ newptr = realloc (ptr, newsize);
+ if (!newptr)
+ goto unlock_done;
+ ptr = newptr;
+ size = newsize;
+ read_pos = size - nbytes_avail + ptr;
}
- c = getc (stream);
- if (c == EOF)
+ /* Here, if size < nmax, nbytes_avail >= buffer_len + 1.
+ If size == nmax, nbytes_avail > 0. */
+
+ if (1 < nbytes_avail)
{
- /* Return partial line, if any. */
- if (read_pos == *lineptr)
- return -1;
+ size_t copy_len = nbytes_avail - 1;
+ if (buffer_len < copy_len)
+ copy_len = buffer_len;
+ if (buffer)
+ memcpy (read_pos, buffer, copy_len);
else
- break;
+ *read_pos = c;
+ read_pos += copy_len;
+ nbytes_avail -= copy_len;
}
- if (nbytes_avail >= 2)
- {
- *read_pos++ = c;
- nbytes_avail--;
- }
+ /* Here still nbytes_avail > 0. */
- if (c == delim1 || (delim2 && c == delim2))
- /* Return the line. */
- break;
+ if (buffer && freadseek (stream, buffer_len))
+ goto unlock_done;
}
+ while (!found_delimiter);
- /* Done - NUL terminate and return the number of chars read.
+ /* Done - NUL terminate and return the number of bytes read.
At this point we know that nbytes_avail >= 1. */
*read_pos = '\0';
- return read_pos - (*lineptr + offset);
+ bytes_stored = read_pos - (ptr + offset);
+
+ unlock_done:
+ funlockfile (stream);
+
+ done:
+ *lineptr = ptr;
+ *linesize = size;
+ return bytes_stored ? bytes_stored : -1;
}
projects / gnulib.git / blobdiff