/****************************************************************************
* libs/libc/stdio/lib_libfgets.c
*
* Copyright (C) 2007-2008, 2011-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include "libc.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Some environments may return CR as end-of-line, others LF, and others
* both. Because of the definition of the getline() function, it can handle
* only single character line terminators.
*/
#undef HAVE_GETLINE
#if defined(CONFIG_EOL_IS_CR)
# define HAVE_GETLINE 1
# define EOLCH '\r'
#elif defined(CONFIG_EOL_IS_LF)
# define HAVE_GETLINE 1
# define EOLCH '\n'
#endif
#define BUFSIZE_INIT 64
#define BUFSIZE_INCR 32
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: getdelim()
*
* Description:
* The getdelim() function will read from stream until it encounters a
* character matching the delimiter character. The delimiter argument
* is an int, the value of which the application will ensure is a
* character representable as an unsigned char of equal value that
* terminates the read process. If the delimiter argument has any other
* value, the behavior is undefined.
*
* The application will ensure that *lineptr is a valid argument that
* could be passed to the free() function. If *n is non-zero, the
* application will ensure that *lineptr either points to an object of
* size at least *n bytes, or is a null pointer.
*
* If *lineptr is a null pointer or if the object pointed to by
* *lineptr is of insufficient size, an object will be allocated as if
* by malloc() or the object will be reallocated as if by realloc(),
* respectively, such that the object is large enough to hold the
* characters to be written to it, including the terminating NUL, and
* *n will be set to the new size. If the object was allocated, or if
* the reallocation operation moved the object, *lineptr will be
* updated to point to the new object or new location. The characters
* read, including any delimiter, will be stored in the object, and a
* terminating NUL added when the delimiter or end-of-file is encountered.
*
* Returned Value:
* Upon successful completion, the getline() and getdelim() functions will
* return the number of bytes written into the buffer, including the
* delimiter character if one was encountered before EOF, but excluding
* the terminating NUL character. If the end-of-file indicator for the
* stream is set, or if no characters were read and the stream is at
* end-of-file, the end-of-file indicator for the stream will be set and
* the function will return -1. If an error occurs, the error indicator for
* the stream will be set, and the function will return -1 and set errno to
* indicate the error.
*
****************************************************************************/
ssize_t getdelim(FAR char **lineptr, size_t *n, int delimiter,
FAR FILE *stream)
{
FAR char *dest;
size_t bufsize;
size_t maxcopy;
ssize_t ncopied;
int ch;
int ret;
/* Verify pointers */
if (lineptr == NULL || n == NULL || stream == NULL)
{
ret = -EINVAL;
goto errout;
}
/* Verify the buffer size */
bufsize = *n;
if (bufsize == 0)
{
/* Pick an initial buffer size */
bufsize = BUFSIZE_INIT;
*n = BUFSIZE_INIT;
/* Free any mystery buffer. It will be reallocated below. */
if (*lineptr != NULL)
{
lib_free(*lineptr);
*lineptr = NULL;
}
}
/* If *lineptr is a NULL pointer, then allocate *lineptr with size *n */
dest = *lineptr;
if (dest == NULL)
{
dest = (FAR char *)lib_malloc(bufsize);
if (dest == NULL)
{
ret = -ENOMEM;
goto errout;
}
*lineptr = dest;
}
/* Transfer characters until either bufsize characters have been transfer
* or until the delimiter is encountered.
*/
ncopied = 0; /* No bytes have been transferred yet */
maxcopy = bufsize - 1; /* Reserve a byte for the NUL terminator */
do
{
/* If the object pointed to by *lineptr is of insufficient size, the
* object will be reallocated such that the object is large enough to
* hold the characters to be written to it, including the terminating
* NUL, and *n will be set to the new size.
*/
if (ncopied >= maxcopy)
{
FAR char *newbuffer;
/* This function should fail with EOVERFLOW if ncopied exceeds
* SSIZE_MAX. However, I think we will have failed a memory
* allocation or crashed long before that could occur.
*/
bufsize += BUFSIZE_INCR;
newbuffer = (FAR char *)lib_realloc(*lineptr, bufsize);
if (newbuffer == NULL)
{
ret = -ENOMEM;
goto errout;
}
*lineptr = newbuffer;
*n = bufsize;
dest = &newbuffer[ncopied];
maxcopy = bufsize - 1;
}
/* Get the next character and test for EOF */
ch = fgetc(stream);
if (ch == EOF)
{
#ifdef __KERNEL_
return -ENODATA;
#else
/* errno is not set in this case */
return -1;
#endif
}
/* Save the character in the user buffer and increment the number of
* bytes transferred.
*/
*dest++ = ch;
ncopied++;
/* Terminate the loop when the delimiter is found or we have hit the
* end of the buffer (reserving a byte for the NUL terminator)
*/
}
while (ch != delimiter);
/* Add a NUL terminator character (but don't report this in the number of
* bytes transferred).
*/
*dest = '\0';
return ncopied;
errout:
#ifdef __KERNEL_
return ret;
#else
set_errno(-ret);
return -1;
#endif
}
/****************************************************************************
* Name: getdelim()
*
* Description:
* The getline() function will be equivalent to the getdelim() function
* with the delimiter character equal to the <newline> character.
*
* NOTE: Because of this functional definition, getline() will not work
* with on systems where multiple characters are used to denote the end
* of line such a CR-LF sequences. In that case, the CR would be
* transferred into the user buffer.
*
****************************************************************************/
#ifdef HAVE_GETLINE
ssize_t getline(FAR char **lineptr, size_t *n, FAR FILE *stream)
{
return getdelim(lineptr, n, EOLCH, stream);
}
#endif