filter.c File Reference

#include "postgres_fe.h"
#include "common/logging.h"
#include "common/string.h"
#include "filter.h"
#include "lib/stringinfo.h"
#include "pqexpbuffer.h"

Include dependency graph for filter.c:

Go to the source code of this file.

Macros
#define	is_keyword_str(cstr, str, bytes)    ((strlen(cstr) == (bytes)) && (pg_strncasecmp((cstr), (str), (bytes)) == 0))

Functions
void	filter_init (FilterStateData *fstate, const char *filename, exit_function f_exit)
void	filter_free (FilterStateData *fstate)
const char *	filter_object_type_name (FilterObjectType fot)
static bool	get_object_type (const char *keyword, int size, FilterObjectType *objtype)
void	pg_log_filter_error (FilterStateData *fstate, const char *fmt,...)
static const char *	filter_get_keyword (const char **line, int *size)
static const char *	read_quoted_string (FilterStateData *fstate, const char *str, PQExpBuffer pattern)
static const char *	read_pattern (FilterStateData *fstate, const char *str, PQExpBuffer pattern)
bool	filter_read_item (FilterStateData *fstate, char **objname, FilterCommandType *comtype, FilterObjectType *objtype)

Macro Definition Documentation

is_keyword_str

#define is_keyword_str	(		cstr,
			str,
			bytes
	)		((strlen(cstr) == (bytes)) && (pg_strncasecmp((cstr), (str), (bytes)) == 0))

Definition at line 22 of file filter.c.

Function Documentation

filter_free()

void filter_free

(

FilterStateData *

fstate

)

Definition at line 60 of file filter.c.

{
    if (!fstate)
        return;
 
    free(fstate->linebuff.data);
    fstate->linebuff.data = NULL;
 
    if (fstate->fp && fstate->fp != stdin)
    {
        if (fclose(fstate->fp) != 0)
            pg_log_error("could not close filter file \"%s\": %m", fstate->filename);
 
        fstate->fp = NULL;
    }
}

References StringInfoData::data, FilterStateData::filename, FilterStateData::fp, free, FilterStateData::linebuff, and pg_log_error.

Referenced by read_dump_filters(), read_dumpall_filters(), and read_restore_filters().

filter_get_keyword()

static const char * filter_get_keyword ( const char **  line, int *  size  )

static

Definition at line 179 of file filter.c.

{
    const char *ptr = *line;
    const char *result = NULL;
 
    /* The passed buffer must not be NULL */
    Assert(*line != NULL);
 
    /* Set returned length preemptively in case no keyword is found */
    *size = 0;
 
    /* Skip initial whitespace */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    /* Grab one keyword that's the string of non-whitespace characters */
    if (*ptr != '\0' && !isspace((unsigned char) *ptr))
    {
        result = ptr++;
 
        while (*ptr != '\0' && !isspace((unsigned char) *ptr))
            ptr++;
 
        *size = ptr - result;
    }
 
    *line = ptr;
 
    return result;
}

References Assert().

Referenced by filter_read_item().

filter_init()

void filter_init	(	FilterStateData *	fstate,
		const char *	filename,
		exit_function	f_exit
	)

Definition at line 36 of file filter.c.

{
    fstate->filename = filename;
    fstate->lineno = 0;
    fstate->exit_nicely = f_exit;
    initStringInfo(&fstate->linebuff);
 
    if (strcmp(filename, "-") != 0)
    {
        fstate->fp = fopen(filename, "r");
        if (!fstate->fp)
        {
            pg_log_error("could not open filter file \"%s\": %m", filename);
            fstate->exit_nicely(1);
        }
    }
    else
        fstate->fp = stdin;
}

References FilterStateData::exit_nicely, FilterStateData::filename, filename, FilterStateData::fp, initStringInfo(), FilterStateData::linebuff, FilterStateData::lineno, and pg_log_error.

Referenced by read_dump_filters(), read_dumpall_filters(), and read_restore_filters().

filter_object_type_name()

const char * filter_object_type_name

(

FilterObjectType

fot

)

Definition at line 82 of file filter.c.

{
    switch (fot)
    {
        case FILTER_OBJECT_TYPE_NONE:
            return "comment or empty line";
        case FILTER_OBJECT_TYPE_TABLE_DATA:
            return "table data";
        case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:
            return "table data and children";
        case FILTER_OBJECT_TYPE_DATABASE:
            return "database";
        case FILTER_OBJECT_TYPE_EXTENSION:
            return "extension";
        case FILTER_OBJECT_TYPE_FOREIGN_DATA:
            return "foreign data";
        case FILTER_OBJECT_TYPE_FUNCTION:
            return "function";
        case FILTER_OBJECT_TYPE_INDEX:
            return "index";
        case FILTER_OBJECT_TYPE_SCHEMA:
            return "schema";
        case FILTER_OBJECT_TYPE_TABLE:
            return "table";
        case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:
            return "table and children";
        case FILTER_OBJECT_TYPE_TRIGGER:
            return "trigger";
    }
 
    /* should never get here */
    pg_unreachable();
}

References FILTER_OBJECT_TYPE_DATABASE, FILTER_OBJECT_TYPE_EXTENSION, FILTER_OBJECT_TYPE_FOREIGN_DATA, FILTER_OBJECT_TYPE_FUNCTION, FILTER_OBJECT_TYPE_INDEX, FILTER_OBJECT_TYPE_NONE, FILTER_OBJECT_TYPE_SCHEMA, FILTER_OBJECT_TYPE_TABLE, FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN, FILTER_OBJECT_TYPE_TABLE_DATA, FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN, FILTER_OBJECT_TYPE_TRIGGER, and pg_unreachable.

Referenced by read_dump_filters(), read_dumpall_filters(), and read_restore_filters().

filter_read_item()

bool filter_read_item	(	FilterStateData *	fstate,
		char **	objname,
		FilterCommandType *	comtype,
		FilterObjectType *	objtype
	)

Definition at line 392 of file filter.c.

{
    if (pg_get_line_buf(fstate->fp, &fstate->linebuff))
    {
        const char *str = fstate->linebuff.data;
        const char *keyword;
        int         size;
        PQExpBufferData pattern;
 
        fstate->lineno++;
 
        /* Skip initial white spaces */
        while (isspace((unsigned char) *str))
            str++;
 
        /*
         * Skip empty lines or lines where the first non-whitespace character
         * is a hash indicating a comment.
         */
        if (*str != '\0' && *str != '#')
        {
            /*
             * First we expect sequence of two keywords, {include|exclude}
             * followed by the object type to operate on.
             */
            keyword = filter_get_keyword(&str, &size);
            if (!keyword)
            {
                pg_log_filter_error(fstate,
                                    _("no filter command found (expected \"include\" or \"exclude\")"));
                fstate->exit_nicely(1);
            }
 
            if (is_keyword_str("include", keyword, size))
                *comtype = FILTER_COMMAND_TYPE_INCLUDE;
            else if (is_keyword_str("exclude", keyword, size))
                *comtype = FILTER_COMMAND_TYPE_EXCLUDE;
            else
            {
                pg_log_filter_error(fstate,
                                    _("invalid filter command (expected \"include\" or \"exclude\")"));
                fstate->exit_nicely(1);
            }
 
            keyword = filter_get_keyword(&str, &size);
            if (!keyword)
            {
                pg_log_filter_error(fstate, _("missing filter object type"));
                fstate->exit_nicely(1);
            }
 
            if (!get_object_type(keyword, size, objtype))
            {
                pg_log_filter_error(fstate,
                                    _("unsupported filter object type: \"%.*s\""), size, keyword);
                fstate->exit_nicely(1);
            }
 
            initPQExpBuffer(&pattern);
 
            str = read_pattern(fstate, str, &pattern);
            *objname = pattern.data;
        }
        else
        {
            *objname = NULL;
            *comtype = FILTER_COMMAND_TYPE_NONE;
            *objtype = FILTER_OBJECT_TYPE_NONE;
        }
 
        return true;
    }
 
    if (ferror(fstate->fp))
    {
        pg_log_error("could not read from filter file \"%s\": %m", fstate->filename);
        fstate->exit_nicely(1);
    }
 
    return false;
}

References _, StringInfoData::data, PQExpBufferData::data, FilterStateData::exit_nicely, FilterStateData::filename, FILTER_COMMAND_TYPE_EXCLUDE, FILTER_COMMAND_TYPE_INCLUDE, FILTER_COMMAND_TYPE_NONE, filter_get_keyword(), FILTER_OBJECT_TYPE_NONE, FilterStateData::fp, get_object_type(), initPQExpBuffer(), is_keyword_str, FilterStateData::linebuff, FilterStateData::lineno, pg_get_line_buf(), pg_log_error, pg_log_filter_error(), read_pattern(), and str.

Referenced by read_dump_filters(), read_dumpall_filters(), and read_restore_filters().

get_object_type()

static bool get_object_type ( const char *  keyword, int  size, FilterObjectType *  objtype  )

static

Definition at line 122 of file filter.c.

{
    if (is_keyword_str("table_data", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_TABLE_DATA;
    else if (is_keyword_str("table_data_and_children", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN;
    else if (is_keyword_str("database", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_DATABASE;
    else if (is_keyword_str("extension", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_EXTENSION;
    else if (is_keyword_str("foreign_data", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_FOREIGN_DATA;
    else if (is_keyword_str("function", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_FUNCTION;
    else if (is_keyword_str("index", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_INDEX;
    else if (is_keyword_str("schema", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_SCHEMA;
    else if (is_keyword_str("table", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_TABLE;
    else if (is_keyword_str("table_and_children", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN;
    else if (is_keyword_str("trigger", keyword, size))
        *objtype = FILTER_OBJECT_TYPE_TRIGGER;
    else
        return false;
 
    return true;
}

References FILTER_OBJECT_TYPE_DATABASE, FILTER_OBJECT_TYPE_EXTENSION, FILTER_OBJECT_TYPE_FOREIGN_DATA, FILTER_OBJECT_TYPE_FUNCTION, FILTER_OBJECT_TYPE_INDEX, FILTER_OBJECT_TYPE_SCHEMA, FILTER_OBJECT_TYPE_TABLE, FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN, FILTER_OBJECT_TYPE_TABLE_DATA, FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN, FILTER_OBJECT_TYPE_TRIGGER, and is_keyword_str.

Referenced by filter_read_item().

pg_log_filter_error()

void pg_log_filter_error	(	FilterStateData *	fstate,
		const char *	fmt,
			...
	)

Definition at line 154 of file filter.c.

{
    va_list     argp;
    char        buf[256];
 
    va_start(argp, fmt);
    vsnprintf(buf, sizeof(buf), fmt, argp);
    va_end(argp);
 
    if (fstate->fp == stdin)
        pg_log_error("invalid format in filter read from standard input on line %d: %s",
                     fstate->lineno, buf);
    else
        pg_log_error("invalid format in filter read from file \"%s\" on line %d: %s",
                     fstate->filename, fstate->lineno, buf);
}

References buf, FilterStateData::filename, FilterStateData::fp, FilterStateData::lineno, pg_log_error, and vsnprintf.

Referenced by filter_read_item(), read_dump_filters(), read_dumpall_filters(), read_pattern(), read_quoted_string(), and read_restore_filters().

read_pattern()

static const char * read_pattern ( FilterStateData *  fstate, const char *  str, PQExpBuffer  pattern  )

static

Definition at line 302 of file filter.c.

{
    bool        skip_space = true;
    bool        found_space = false;
 
    /* Skip initial whitespace */
    while (isspace((unsigned char) *str))
        str++;
 
    if (*str == '\0')
    {
        pg_log_filter_error(fstate, _("missing object name pattern"));
        fstate->exit_nicely(1);
    }
 
    while (*str && *str != '#')
    {
        while (*str && !isspace((unsigned char) *str) && !strchr("#,.()\"", *str))
        {
            /*
             * Append space only when it is allowed, and when it was found in
             * original string.
             */
            if (!skip_space && found_space)
            {
                appendPQExpBufferChar(pattern, ' ');
                skip_space = true;
            }
 
            appendPQExpBufferChar(pattern, *str++);
        }
 
        skip_space = false;
 
        if (*str == '"')
        {
            if (found_space)
                appendPQExpBufferChar(pattern, ' ');
 
            str = read_quoted_string(fstate, str, pattern);
        }
        else if (*str == ',')
        {
            appendPQExpBufferStr(pattern, ", ");
            skip_space = true;
            str++;
        }
        else if (*str && strchr(".()", *str))
        {
            appendPQExpBufferChar(pattern, *str++);
            skip_space = true;
        }
 
        found_space = false;
 
        /* skip ending whitespaces */
        while (isspace((unsigned char) *str))
        {
            found_space = true;
            str++;
        }
    }
 
    return str;
}

References _, appendPQExpBufferChar(), appendPQExpBufferStr(), FilterStateData::exit_nicely, pg_log_filter_error(), read_quoted_string(), and str.

Referenced by filter_read_item().

read_quoted_string()

static const char * read_quoted_string ( FilterStateData *  fstate, const char *  str, PQExpBuffer  pattern  )

static

Definition at line 217 of file filter.c.

{
    appendPQExpBufferChar(pattern, '"');
    str++;
 
    while (1)
    {
        /*
         * We can ignore \r or \n chars because the string is read by
         * pg_get_line_buf, so these chars should be just trailing chars.
         */
        if (*str == '\r' || *str == '\n')
        {
            str++;
            continue;
        }
 
        if (*str == '\0')
        {
            Assert(fstate->linebuff.data);
 
            if (!pg_get_line_buf(fstate->fp, &fstate->linebuff))
            {
                if (ferror(fstate->fp))
                    pg_log_error("could not read from filter file \"%s\": %m",
                                 fstate->filename);
                else
                    pg_log_filter_error(fstate, _("unexpected end of file"));
 
                fstate->exit_nicely(1);
            }
 
            str = fstate->linebuff.data;
 
            appendPQExpBufferChar(pattern, '\n');
            fstate->lineno++;
        }
 
        if (*str == '"')
        {
            appendPQExpBufferChar(pattern, '"');
            str++;
 
            if (*str == '"')
            {
                appendPQExpBufferChar(pattern, '"');
                str++;
            }
            else
                break;
        }
        else if (*str == '\\')
        {
            str++;
            if (*str == 'n')
                appendPQExpBufferChar(pattern, '\n');
            else if (*str == '\\')
                appendPQExpBufferChar(pattern, '\\');
 
            str++;
        }
        else
            appendPQExpBufferChar(pattern, *str++);
    }
 
    return str;
}

References _, appendPQExpBufferChar(), Assert(), StringInfoData::data, FilterStateData::exit_nicely, FilterStateData::filename, FilterStateData::fp, FilterStateData::linebuff, FilterStateData::lineno, pg_get_line_buf(), pg_log_error, pg_log_filter_error(), and str.

Referenced by read_pattern().