mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-10-02 11:01:18 +02:00
c8e1ba736b
Backpatch-through: 11
181 lines
5.6 KiB
C
181 lines
5.6 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* pg_get_line.c
|
|
* fgets() with an expansible result buffer
|
|
*
|
|
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* src/common/pg_get_line.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#ifndef FRONTEND
|
|
#include "postgres.h"
|
|
#else
|
|
#include "postgres_fe.h"
|
|
#endif
|
|
|
|
#include <setjmp.h>
|
|
|
|
#include "common/string.h"
|
|
#include "lib/stringinfo.h"
|
|
|
|
|
|
/*
|
|
* pg_get_line()
|
|
*
|
|
* This is meant to be equivalent to fgets(), except that instead of
|
|
* reading into a caller-supplied, fixed-size buffer, it reads into
|
|
* a palloc'd (in frontend, really malloc'd) string, which is resized
|
|
* as needed to handle indefinitely long input lines. The caller is
|
|
* responsible for pfree'ing the result string when appropriate.
|
|
*
|
|
* As with fgets(), returns NULL if there is a read error or if no
|
|
* characters are available before EOF. The caller can distinguish
|
|
* these cases by checking ferror(stream).
|
|
*
|
|
* Since this is meant to be equivalent to fgets(), the trailing newline
|
|
* (if any) is not stripped. Callers may wish to apply pg_strip_crlf().
|
|
*
|
|
* Note that while I/O errors are reflected back to the caller to be
|
|
* dealt with, an OOM condition for the palloc'd buffer will not be;
|
|
* there'll be an ereport(ERROR) or exit(1) inside stringinfo.c.
|
|
*
|
|
* Also note that the palloc'd buffer is usually a lot longer than
|
|
* strictly necessary, so it may be inadvisable to use this function
|
|
* to collect lots of long-lived data. A less memory-hungry option
|
|
* is to use pg_get_line_buf() or pg_get_line_append() in a loop,
|
|
* then pstrdup() each line.
|
|
*
|
|
* prompt_ctx can optionally be provided to allow this function to be
|
|
* canceled via an existing SIGINT signal handler that will longjmp to the
|
|
* specified place only when *(prompt_ctx->enabled) is true. If canceled,
|
|
* this function returns NULL, and prompt_ctx->canceled is set to true.
|
|
*/
|
|
char *
|
|
pg_get_line(FILE *stream, PromptInterruptContext *prompt_ctx)
|
|
{
|
|
StringInfoData buf;
|
|
|
|
initStringInfo(&buf);
|
|
|
|
if (!pg_get_line_append(stream, &buf, prompt_ctx))
|
|
{
|
|
/* ensure that free() doesn't mess up errno */
|
|
int save_errno = errno;
|
|
|
|
pfree(buf.data);
|
|
errno = save_errno;
|
|
return NULL;
|
|
}
|
|
|
|
return buf.data;
|
|
}
|
|
|
|
/*
|
|
* pg_get_line_buf()
|
|
*
|
|
* This has similar behavior to pg_get_line(), and thence to fgets(),
|
|
* except that the collected data is returned in a caller-supplied
|
|
* StringInfo buffer. This is a convenient API for code that just
|
|
* wants to read and process one line at a time, without any artificial
|
|
* limit on line length.
|
|
*
|
|
* Returns true if a line was successfully collected (including the
|
|
* case of a non-newline-terminated line at EOF). Returns false if
|
|
* there was an I/O error or no data was available before EOF.
|
|
* (Check ferror(stream) to distinguish these cases.)
|
|
*
|
|
* In the false-result case, buf is reset to empty.
|
|
*/
|
|
bool
|
|
pg_get_line_buf(FILE *stream, StringInfo buf)
|
|
{
|
|
/* We just need to drop any data from the previous call */
|
|
resetStringInfo(buf);
|
|
return pg_get_line_append(stream, buf, NULL);
|
|
}
|
|
|
|
/*
|
|
* pg_get_line_append()
|
|
*
|
|
* This has similar behavior to pg_get_line(), and thence to fgets(),
|
|
* except that the collected data is appended to whatever is in *buf.
|
|
* This is useful in preference to pg_get_line_buf() if the caller wants
|
|
* to merge some lines together, e.g. to implement backslash continuation.
|
|
*
|
|
* Returns true if a line was successfully collected (including the
|
|
* case of a non-newline-terminated line at EOF). Returns false if
|
|
* there was an I/O error or no data was available before EOF.
|
|
* (Check ferror(stream) to distinguish these cases.)
|
|
*
|
|
* In the false-result case, the contents of *buf are logically unmodified,
|
|
* though it's possible that the buffer has been resized.
|
|
*
|
|
* prompt_ctx can optionally be provided to allow this function to be
|
|
* canceled via an existing SIGINT signal handler that will longjmp to the
|
|
* specified place only when *(prompt_ctx->enabled) is true. If canceled,
|
|
* this function returns false, and prompt_ctx->canceled is set to true.
|
|
*/
|
|
bool
|
|
pg_get_line_append(FILE *stream, StringInfo buf,
|
|
PromptInterruptContext *prompt_ctx)
|
|
{
|
|
int orig_len = buf->len;
|
|
|
|
if (prompt_ctx && sigsetjmp(*((sigjmp_buf *) prompt_ctx->jmpbuf), 1) != 0)
|
|
{
|
|
/* Got here with longjmp */
|
|
prompt_ctx->canceled = true;
|
|
/* Discard any data we collected before detecting error */
|
|
buf->len = orig_len;
|
|
buf->data[orig_len] = '\0';
|
|
return false;
|
|
}
|
|
|
|
/* Loop until newline or EOF/error */
|
|
for (;;)
|
|
{
|
|
char *res;
|
|
|
|
/* Enable longjmp while waiting for input */
|
|
if (prompt_ctx)
|
|
*(prompt_ctx->enabled) = true;
|
|
|
|
/* Read some data, appending it to whatever we already have */
|
|
res = fgets(buf->data + buf->len, buf->maxlen - buf->len, stream);
|
|
|
|
/* Disable longjmp again, then break if fgets failed */
|
|
if (prompt_ctx)
|
|
*(prompt_ctx->enabled) = false;
|
|
|
|
if (res == NULL)
|
|
break;
|
|
|
|
/* Got data, so update buf->len */
|
|
buf->len += strlen(buf->data + buf->len);
|
|
|
|
/* Done if we have collected a newline */
|
|
if (buf->len > orig_len && buf->data[buf->len - 1] == '\n')
|
|
return true;
|
|
|
|
/* Make some more room in the buffer, and loop to read more data */
|
|
enlargeStringInfo(buf, 128);
|
|
}
|
|
|
|
/* Check for I/O errors and EOF */
|
|
if (ferror(stream) || buf->len == orig_len)
|
|
{
|
|
/* Discard any data we collected before detecting error */
|
|
buf->len = orig_len;
|
|
buf->data[orig_len] = '\0';
|
|
return false;
|
|
}
|
|
|
|
/* No newline at EOF, but we did collect some data */
|
|
return true;
|
|
}
|