mirror of
git://git.gnupg.org/gnupg.git
synced 2024-11-05 20:48:52 +01:00
118 lines
3.6 KiB
C
118 lines
3.6 KiB
C
/* xreadline.c - fgets replacement function
|
|
* Copyright (C) 1999, 2004 Free Software Foundation, Inc.
|
|
*
|
|
* This file is part of GnuPG.
|
|
*
|
|
* GnuPG 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GnuPG 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
|
|
#include "util.h"
|
|
|
|
|
|
/* Same as fgets() but if the provided buffer is too short a larger
|
|
one will be allocated. This is similar to getline. A line is
|
|
considered a byte stream ending in a LF.
|
|
|
|
If MAX_LENGTH is not NULL, it shall point to a value with the
|
|
maximum allowed allocation.
|
|
|
|
Returns the length of the line. EOF is indicated by a line of
|
|
length zero. A truncated line is indicated by setting the value at
|
|
MAX_LENGTH to 0. If the returned value is less then 0 not enough
|
|
memory was enable and ERRNO is set accordingly.
|
|
|
|
If a line has been truncated, the file pointer is moved forward to
|
|
the end of the line so that the next read starts with the next
|
|
line. Note that MAX_LENGTH must be re-initialzied in this case.
|
|
|
|
Note: The returned buffer is allocated with enough extra space to
|
|
append a CR,LF,Nul
|
|
*/
|
|
ssize_t
|
|
read_line (FILE *fp,
|
|
char **addr_of_buffer, size_t *length_of_buffer,
|
|
size_t *max_length)
|
|
{
|
|
int c;
|
|
char *buffer = *addr_of_buffer;
|
|
size_t length = *length_of_buffer;
|
|
size_t nbytes = 0;
|
|
size_t maxlen = max_length? *max_length : 0;
|
|
char *p;
|
|
|
|
if (!buffer)
|
|
{ /* No buffer given - allocate a new one. */
|
|
length = 256;
|
|
buffer = xtrymalloc (length);
|
|
*addr_of_buffer = buffer;
|
|
if (!buffer)
|
|
{
|
|
*length_of_buffer = 0;
|
|
if (max_length)
|
|
*max_length = 0;
|
|
return -1;
|
|
}
|
|
*length_of_buffer = length;
|
|
}
|
|
|
|
length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
|
|
p = buffer;
|
|
while ((c = getc (fp)) != EOF)
|
|
{
|
|
if (nbytes == length)
|
|
{ /* Enlarge the buffer. */
|
|
if (maxlen && length > maxlen) /* But not beyond our limit. */
|
|
{
|
|
/* Skip the rest of the line. */
|
|
while (c != '\n' && (c=getc (fp)) != EOF)
|
|
;
|
|
*p++ = '\n'; /* Always append a LF (we reserved some space). */
|
|
nbytes++;
|
|
if (max_length)
|
|
*max_length = 0; /* Indicate truncation. */
|
|
break; /* the while loop. */
|
|
}
|
|
length += 3; /* Adjust for the reserved bytes. */
|
|
length += length < 1024? 256 : 1024;
|
|
*addr_of_buffer = xtryrealloc (buffer, length);
|
|
if (!*addr_of_buffer)
|
|
{
|
|
int save_errno = errno;
|
|
xfree (buffer);
|
|
*length_of_buffer = 0;
|
|
if (max_length)
|
|
*max_length = 0;
|
|
errno = save_errno;
|
|
return -1;
|
|
}
|
|
buffer = *addr_of_buffer;
|
|
*length_of_buffer = length;
|
|
length -= 3;
|
|
p = buffer + nbytes;
|
|
}
|
|
*p++ = c;
|
|
nbytes++;
|
|
if (c == '\n')
|
|
break;
|
|
}
|
|
*p = 0; /* Make sure the line is a string. */
|
|
|
|
return nbytes;
|
|
}
|