guc-file.l File Reference

#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include "common/file_utils.h"
#include "guc_internal.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/conffiles.h"
#include "utils/memutils.h"

Include dependency graph for guc-file.l:

Go to the source code of this file.

Macros
#define	fprintf(file, fmt, msg)   GUC_flex_fatal(msg)

Enumerations
enum	{   GUC_ID = 1 , GUC_STRING = 2 , GUC_INTEGER = 3 , GUC_REAL = 4 ,   GUC_EQUALS = 5 , GUC_UNQUOTED_STRING = 6 , GUC_QUALIFIED_ID = 7 , GUC_EOL = 99 ,   GUC_ERROR = 100 }

Functions
static void	FreeConfigVariable (ConfigVariable *item)
static int	GUC_flex_fatal (const char *msg)
int	yylex (yyscan_t yyscanner)
void	ProcessConfigFile (GucContext context)
bool	ParseConfigFile (const char *config_file, bool strict, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
void	record_config_file_error (const char *errmsg, const char *config_file, int lineno, ConfigVariable **head_p, ConfigVariable **tail_p)
bool	ParseConfigFp (FILE *fp, const char *config_file, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
bool	ParseConfigDirectory (const char *includedir, const char *calling_file, int calling_lineno, int depth, int elevel, ConfigVariable **head_p, ConfigVariable **tail_p)
void	FreeConfigVariables (ConfigVariable *list)
char *	DeescapeQuotedString (const char *s)

Variables
static unsigned int	ConfigFileLineno
static const char *	GUC_flex_fatal_errmsg
static sigjmp_buf *	GUC_flex_fatal_jmp

Macro Definition Documentation

fprintf

#define fprintf	(		file,
			fmt,
			msg
	)		GUC_flex_fatal(msg)

Definition at line 33 of file guc-file.l.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
GUC_ID
GUC_STRING
GUC_INTEGER
GUC_REAL
GUC_EQUALS
GUC_UNQUOTED_STRING
GUC_QUALIFIED_ID
GUC_EOL
GUC_ERROR

Definition at line 35 of file guc-file.l.

{
    GUC_ID = 1,
    GUC_STRING = 2,
    GUC_INTEGER = 3,
    GUC_REAL = 4,
    GUC_EQUALS = 5,
    GUC_UNQUOTED_STRING = 6,
    GUC_QUALIFIED_ID = 7,
    GUC_EOL = 99,
    GUC_ERROR = 100
};

Function Documentation

DeescapeQuotedString()

char * DeescapeQuotedString

(

const char *

s

)

Definition at line 661 of file guc-file.l.

{
    char       *newStr;
    int         len,
                i,
                j;
 
    /* We just Assert that there are leading and trailing quotes */
    Assert(s != NULL && s[0] == '\'');
    len = strlen(s);
    Assert(len >= 2);
    Assert(s[len - 1] == '\'');
 
    /* Skip the leading quote; we'll handle the trailing quote below */
    s++, len--;
 
    /* Since len still includes trailing quote, this is enough space */
    newStr = palloc(len);
 
    for (i = 0, j = 0; i < len; i++)
    {
        if (s[i] == '\\')
        {
            i++;
            switch (s[i])
            {
                case 'b':
                    newStr[j] = '\b';
                    break;
                case 'f':
                    newStr[j] = '\f';
                    break;
                case 'n':
                    newStr[j] = '\n';
                    break;
                case 'r':
                    newStr[j] = '\r';
                    break;
                case 't':
                    newStr[j] = '\t';
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                        int         k;
                        long        octVal = 0;
 
                        for (k = 0;
                             s[i + k] >= '0' && s[i + k] <= '7' && k < 3;
                             k++)
                            octVal = (octVal << 3) + (s[i + k] - '0');
                        i += k - 1;
                        newStr[j] = ((char) octVal);
                    }
                    break;
                default:
                    newStr[j] = s[i];
                    break;
            }                   /* switch */
        }
        else if (s[i] == '\'' && s[i + 1] == '\'')
        {
            /* doubled quote becomes just one quote */
            newStr[j] = s[++i];
        }
        else
            newStr[j] = s[i];
        j++;
    }
 
    /* We copied the ending quote to newStr, so replace with \0 */
    Assert(j > 0 && j <= len);
    newStr[--j] = '\0';
 
    return newStr;
}

References Assert(), i, j, len, and palloc().

Referenced by ParseConfigFp().

FreeConfigVariable()

static void FreeConfigVariable ( ConfigVariable *  item )

static

Definition at line 635 of file guc-file.l.

{
    if (item->name)
        pfree(item->name);
    if (item->value)
        pfree(item->value);
    if (item->errmsg)
        pfree(item->errmsg);
    if (item->filename)
        pfree(item->filename);
    pfree(item);
}

References ConfigVariable::errmsg, ConfigVariable::filename, ConfigVariable::name, pfree(), and ConfigVariable::value.

Referenced by FreeConfigVariables().

FreeConfigVariables()

void FreeConfigVariables

(

ConfigVariable *

list

)

Definition at line 617 of file guc-file.l.

{
    ConfigVariable *item;
 
    item = list;
    while (item)
    {
        ConfigVariable *next = item->next;
 
        FreeConfigVariable(item);
        item = next;
    }
}

References FreeConfigVariable(), sort-test::list, next, and ConfigVariable::next.

Referenced by AlterSystemSetConfigFile(), and parse_extension_control_file().

GUC_flex_fatal()

static int GUC_flex_fatal ( const char *  msg )

static

Definition at line 311 of file guc-file.l.

{
    GUC_flex_fatal_errmsg = msg;
    siglongjmp(*GUC_flex_fatal_jmp, 1);
    return 0;                   /* keep compiler quiet */
}

References GUC_flex_fatal_errmsg, and GUC_flex_fatal_jmp.

ParseConfigDirectory()

bool ParseConfigDirectory	(	const char *	includedir,
		const char *	calling_file,
		int	calling_lineno,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

Definition at line 581 of file guc-file.l.

{
    char       *err_msg;
    char      **filenames;
    int         num_filenames;
 
    filenames = GetConfFilesInDir(includedir, calling_file, elevel,
                                  &num_filenames, &err_msg);
 
    if (!filenames)
    {
        record_config_file_error(err_msg, calling_file, calling_lineno, head_p,
                                 tail_p);
        return false;
    }
 
    for (int i = 0; i < num_filenames; i++)
    {
        if (!ParseConfigFile(filenames[i], true,
                             calling_file, calling_lineno,
                             depth, elevel,
                             head_p, tail_p))
            return false;
    }
 
    return true;
}

References GetConfFilesInDir(), i, ParseConfigFile(), and record_config_file_error().

Referenced by ParseConfigFp().

ParseConfigFile()

bool ParseConfigFile	(	const char *	config_file,
		bool	strict,
		const char *	calling_file,
		int	calling_lineno,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

Definition at line 175 of file guc-file.l.

{
    char       *abs_path;
    bool        OK = true;
    FILE       *fp;
 
    /*
     * Reject file name that is all-blank (including empty), as that leads to
     * confusion --- we'd try to read the containing directory as a file.
     */
    if (strspn(config_file, " \t\r\n") == strlen(config_file))
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("empty configuration file name: \"%s\"",
                        config_file)));
        record_config_file_error("empty configuration file name",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        return false;
    }
 
    /*
     * Reject too-deep include nesting depth.  This is just a safety check to
     * avoid dumping core due to stack overflow if an include file loops back
     * to itself.  The maximum nesting depth is pretty arbitrary.
     */
    if (depth > CONF_FILE_MAX_DEPTH)
    {
        ereport(elevel,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("could not open configuration file \"%s\": maximum nesting depth exceeded",
                        config_file)));
        record_config_file_error("nesting depth exceeded",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        return false;
    }
 
    abs_path = AbsoluteConfigLocation(config_file, calling_file);
 
    /*
     * Reject direct recursion.  Indirect recursion is also possible, but it's
     * harder to detect and so doesn't seem worth the trouble.  (We test at
     * this step because the canonicalization done by AbsoluteConfigLocation
     * makes it more likely that a simple strcmp comparison will match.)
     */
    if (calling_file && strcmp(abs_path, calling_file) == 0)
    {
        ereport(elevel,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("configuration file recursion in \"%s\"",
                        calling_file)));
        record_config_file_error("configuration file recursion",
                                 calling_file, calling_lineno,
                                 head_p, tail_p);
        pfree(abs_path);
        return false;
    }
 
    fp = AllocateFile(abs_path, "r");
    if (!fp)
    {
        if (strict)
        {
            ereport(elevel,
                    (errcode_for_file_access(),
                     errmsg("could not open configuration file \"%s\": %m",
                            abs_path)));
            record_config_file_error(psprintf("could not open file \"%s\"",
                                              abs_path),
                                     calling_file, calling_lineno,
                                     head_p, tail_p);
            OK = false;
        }
        else
        {
            ereport(LOG,
                    (errmsg("skipping missing configuration file \"%s\"",
                            abs_path)));
        }
        goto cleanup;
    }
 
    OK = ParseConfigFp(fp, abs_path, depth, elevel, head_p, tail_p);
 
cleanup:
    if (fp)
        FreeFile(fp);
    pfree(abs_path);
 
    return OK;
}

References AbsoluteConfigLocation(), AllocateFile(), cleanup(), CONF_FILE_MAX_DEPTH, config_file, ereport, errcode(), errcode_for_file_access(), errmsg(), FreeFile(), LOG, ParseConfigFp(), pfree(), psprintf(), and record_config_file_error().

Referenced by ParseConfigDirectory(), ParseConfigFp(), and ProcessConfigFileInternal().

ParseConfigFp()

bool ParseConfigFp	(	FILE *	fp,
		const char *	config_file,
		int	depth,
		int	elevel,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

Definition at line 350 of file guc-file.l.

{
    volatile bool OK = true;
    unsigned int save_ConfigFileLineno = ConfigFileLineno;
    sigjmp_buf *save_GUC_flex_fatal_jmp = GUC_flex_fatal_jmp;
    sigjmp_buf  flex_fatal_jmp;
    yyscan_t    scanner;
    struct yyguts_t *yyg;       /* needed for yytext macro */
    volatile YY_BUFFER_STATE lex_buffer = NULL;
    int         errorcount;
    int         token;
 
    if (sigsetjmp(flex_fatal_jmp, 1) == 0)
        GUC_flex_fatal_jmp = &flex_fatal_jmp;
    else
    {
        /*
         * Regain control after a fatal, internal flex error.  It may have
         * corrupted parser state.  Consequently, abandon the file, but trust
         * that the state remains sane enough for yy_delete_buffer().
         */
        elog(elevel, "%s at file \"%s\" line %u",
             GUC_flex_fatal_errmsg, config_file, ConfigFileLineno);
        record_config_file_error(GUC_flex_fatal_errmsg,
                                 config_file, ConfigFileLineno,
                                 head_p, tail_p);
        OK = false;
        goto cleanup;
    }
 
    /*
     * Parse
     */
    ConfigFileLineno = 1;
    errorcount = 0;
 
    if (yylex_init(&scanner) != 0)
        elog(elevel, "yylex_init() failed: %m");
    yyg = (struct yyguts_t *) scanner;
 
    lex_buffer = yy_create_buffer(fp, YY_BUF_SIZE, scanner);
    yy_switch_to_buffer(lex_buffer, scanner);
 
    /* This loop iterates once per logical line */
    while ((token = yylex(scanner)))
    {
        char       *opt_name = NULL;
        char       *opt_value = NULL;
        ConfigVariable *item;
 
        if (token == GUC_EOL)   /* empty or comment line */
            continue;
 
        /* first token on line is option name */
        if (token != GUC_ID && token != GUC_QUALIFIED_ID)
            goto parse_error;
        opt_name = pstrdup(yytext);
 
        /* next we have an optional equal sign; discard if present */
        token = yylex(scanner);
        if (token == GUC_EQUALS)
            token = yylex(scanner);
 
        /* now we must have the option value */
        if (token != GUC_ID &&
            token != GUC_STRING &&
            token != GUC_INTEGER &&
            token != GUC_REAL &&
            token != GUC_UNQUOTED_STRING)
            goto parse_error;
        if (token == GUC_STRING)    /* strip quotes and escapes */
            opt_value = DeescapeQuotedString(yytext);
        else
            opt_value = pstrdup(yytext);
 
        /* now we'd like an end of line, or possibly EOF */
        token = yylex(scanner);
        if (token != GUC_EOL)
        {
            if (token != 0)
                goto parse_error;
            /* treat EOF like \n for line numbering purposes, cf bug 4752 */
            ConfigFileLineno++;
        }
 
        /* OK, process the option name and value */
        if (guc_name_compare(opt_name, "include_dir") == 0)
        {
            /*
             * An include_dir directive isn't a variable and should be
             * processed immediately.
             */
            if (!ParseConfigDirectory(opt_value,
                                      config_file, ConfigFileLineno - 1,
                                      depth + 1, elevel,
                                      head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else if (guc_name_compare(opt_name, "include_if_exists") == 0)
        {
            /*
             * An include_if_exists directive isn't a variable and should be
             * processed immediately.
             */
            if (!ParseConfigFile(opt_value, false,
                                 config_file, ConfigFileLineno - 1,
                                 depth + 1, elevel,
                                 head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else if (guc_name_compare(opt_name, "include") == 0)
        {
            /*
             * An include directive isn't a variable and should be processed
             * immediately.
             */
            if (!ParseConfigFile(opt_value, true,
                                 config_file, ConfigFileLineno - 1,
                                 depth + 1, elevel,
                                 head_p, tail_p))
                OK = false;
            yy_switch_to_buffer(lex_buffer, scanner);
            pfree(opt_name);
            pfree(opt_value);
        }
        else
        {
            /* ordinary variable, append to list */
            item = palloc(sizeof *item);
            item->name = opt_name;
            item->value = opt_value;
            item->errmsg = NULL;
            item->filename = pstrdup(config_file);
            item->sourceline = ConfigFileLineno - 1;
            item->ignore = false;
            item->applied = false;
            item->next = NULL;
            if (*head_p == NULL)
                *head_p = item;
            else
                (*tail_p)->next = item;
            *tail_p = item;
        }
 
        /* break out of loop if read EOF, else loop for next line */
        if (token == 0)
            break;
        continue;
 
parse_error:
        /* release storage if we allocated any on this line */
        if (opt_name)
            pfree(opt_name);
        if (opt_value)
            pfree(opt_value);
 
        /* report the error */
        if (token == GUC_EOL || token == 0)
        {
            ereport(elevel,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("syntax error in file \"%s\" line %u, near end of line",
                            config_file, ConfigFileLineno - 1)));
            record_config_file_error("syntax error",
                                     config_file, ConfigFileLineno - 1,
                                     head_p, tail_p);
        }
        else
        {
            ereport(elevel,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
                            config_file, ConfigFileLineno, yytext)));
            record_config_file_error("syntax error",
                                     config_file, ConfigFileLineno,
                                     head_p, tail_p);
        }
        OK = false;
        errorcount++;
 
        /*
         * To avoid producing too much noise when fed a totally bogus file,
         * give up after 100 syntax errors per file (an arbitrary number).
         * Also, if we're only logging the errors at DEBUG level anyway, might
         * as well give up immediately.  (This prevents postmaster children
         * from bloating the logs with duplicate complaints.)
         */
        if (errorcount >= 100 || elevel <= DEBUG1)
        {
            ereport(elevel,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("too many syntax errors found, abandoning file \"%s\"",
                            config_file)));
            break;
        }
 
        /* resync to next end-of-line or EOF */
        while (token != GUC_EOL && token != 0)
            token = yylex(scanner);
        /* break out of loop on EOF */
        if (token == 0)
            break;
    }
 
cleanup:
    yy_delete_buffer(lex_buffer, scanner);
    yylex_destroy(scanner);
    /* Each recursion level must save and restore these static variables. */
    ConfigFileLineno = save_ConfigFileLineno;
    GUC_flex_fatal_jmp = save_GUC_flex_fatal_jmp;
    return OK;
}

References ConfigVariable::applied, cleanup(), config_file, ConfigFileLineno, DEBUG1, DeescapeQuotedString(), elog, ereport, errcode(), errmsg(), ConfigVariable::errmsg, ConfigVariable::filename, GUC_EOL, GUC_EQUALS, GUC_flex_fatal_errmsg, GUC_flex_fatal_jmp, GUC_ID, GUC_INTEGER, guc_name_compare(), GUC_QUALIFIED_ID, GUC_REAL, GUC_STRING, GUC_UNQUOTED_STRING, ConfigVariable::ignore, ConfigVariable::name, ConfigVariable::next, palloc(), ParseConfigDirectory(), ParseConfigFile(), pfree(), pstrdup(), record_config_file_error(), ConfigVariable::sourceline, token, ConfigVariable::value, and yylex().

Referenced by AlterSystemSetConfigFile(), parse_extension_control_file(), and ParseConfigFile().

ProcessConfigFile()

void ProcessConfigFile

(

GucContext

context

)

Definition at line 120 of file guc-file.l.

{
    int         elevel;
    MemoryContext config_cxt;
    MemoryContext caller_cxt;
 
    /*
     * Config files are processed on startup (by the postmaster only) and on
     * SIGHUP (by the postmaster and its children)
     */
    Assert((context == PGC_POSTMASTER && !IsUnderPostmaster) ||
           context == PGC_SIGHUP);
 
    /*
     * To avoid cluttering the log, only the postmaster bleats loudly about
     * problems with the config file.
     */
    elevel = IsUnderPostmaster ? DEBUG2 : LOG;
 
    /*
     * This function is usually called within a process-lifespan memory
     * context.  To ensure that any memory leaked during GUC processing does
     * not accumulate across repeated SIGHUP cycles, do the work in a private
     * context that we can free at exit.
     */
    config_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                       "config file processing",
                                       ALLOCSET_DEFAULT_SIZES);
    caller_cxt = MemoryContextSwitchTo(config_cxt);
 
    /*
     * Read and apply the config file.  We don't need to examine the result.
     */
    (void) ProcessConfigFileInternal(context, true, elevel);
 
    /* Clean up */
    MemoryContextSwitchTo(caller_cxt);
    MemoryContextDelete(config_cxt);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CurrentMemoryContext, DEBUG2, IsUnderPostmaster, LOG, MemoryContextDelete(), MemoryContextSwitchTo(), PGC_POSTMASTER, PGC_SIGHUP, and ProcessConfigFileInternal().

Referenced by ApplyLauncherMain(), autoprewarm_main(), CheckpointWriteDelay(), copy_sequences(), do_autovacuum(), IoWorkerMain(), LogicalRepApplyLoop(), PostgresMain(), process_pm_reload_request(), ProcessAutoVacLauncherInterrupts(), ProcessCheckpointerInterrupts(), ProcessMainLoopInterrupts(), ProcessParallelApplyInterrupts(), ProcessPendingWrites(), ProcessPgArchInterrupts(), ProcessWalSummarizerInterrupts(), SelectConfigFiles(), slotsync_reread_config(), StartupRereadConfig(), SysLoggerMain(), vacuum_delay_point(), WaitForStandbyConfirmation(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), and worker_spi_main().

record_config_file_error()

void record_config_file_error	(	const char *	errmsg,
		const char *	config_file,
		int	lineno,
		ConfigVariable **	head_p,
		ConfigVariable **	tail_p
	)

Definition at line 278 of file guc-file.l.

{
    ConfigVariable *item;
 
    item = palloc(sizeof *item);
    item->name = NULL;
    item->value = NULL;
    item->errmsg = pstrdup(errmsg);
    item->filename = config_file ? pstrdup(config_file) : NULL;
    item->sourceline = lineno;
    item->ignore = true;
    item->applied = false;
    item->next = NULL;
    if (*head_p == NULL)
        *head_p = item;
    else
        (*tail_p)->next = item;
    *tail_p = item;
}

References ConfigVariable::applied, config_file, errmsg(), ConfigVariable::errmsg, ConfigVariable::filename, ConfigVariable::ignore, ConfigVariable::name, ConfigVariable::next, palloc(), pstrdup(), ConfigVariable::sourceline, and ConfigVariable::value.

Referenced by ParseConfigDirectory(), ParseConfigFile(), ParseConfigFp(), and ProcessConfigFileInternal().

yylex()

int yylex

(

yyscan_t

yyscanner

)

Definition at line 91 of file guc-file.l.

{ID}            return GUC_ID;
{QUALIFIED_ID}  return GUC_QUALIFIED_ID;
{STRING}        return GUC_STRING;
{UNQUOTED_STRING} return GUC_UNQUOTED_STRING;
{INTEGER}       return GUC_INTEGER;
{REAL}          return GUC_REAL;
=               return GUC_EQUALS;
 
.               return GUC_ERROR;
 
%%

Referenced by ParseConfigFp().

Variable Documentation

ConfigFileLineno

unsigned int ConfigFileLineno

static

Definition at line 48 of file guc-file.l.

Referenced by ParseConfigFp().

GUC_flex_fatal_errmsg

const char* GUC_flex_fatal_errmsg

static

Definition at line 49 of file guc-file.l.

Referenced by GUC_flex_fatal(), and ParseConfigFp().

GUC_flex_fatal_jmp

sigjmp_buf* GUC_flex_fatal_jmp

static

Definition at line 50 of file guc-file.l.

Referenced by GUC_flex_fatal(), and ParseConfigFp().