Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

PostgreSQL Source Code git master
filter.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * filter.c
4 * Implementation of simple filter file parser
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * src/bin/pg_dump/filter.c
11 *
12 *-------------------------------------------------------------------------
13 */
14#include "postgres_fe.h"
15
16#include "common/logging.h"
17#include "common/string.h"
18#include "filter.h"
19#include "lib/stringinfo.h"
20#include "pqexpbuffer.h"
21
22#define is_keyword_str(cstr, str, bytes) \
23 ((strlen(cstr) == (bytes)) && (pg_strncasecmp((cstr), (str), (bytes)) == 0))
24
25/*
26 * Following routines are called from pg_dump, pg_dumpall and pg_restore.
27 * Since the implementation of exit_nicely is application specific, each
28 * application need to pass a function pointer to the exit_nicely function to
29 * use for exiting on errors.
30 */
31
32/*
33 * Opens filter's file and initialize fstate structure.
34 */
35void
37{
38 fstate->filename = filename;
39 fstate->lineno = 0;
40 fstate->exit_nicely = f_exit;
41 initStringInfo(&fstate->linebuff);
42
43 if (strcmp(filename, "-") != 0)
44 {
45 fstate->fp = fopen(filename, "r");
46 if (!fstate->fp)
47 {
48 pg_log_error("could not open filter file \"%s\": %m", filename);
49 fstate->exit_nicely(1);
50 }
51 }
52 else
53 fstate->fp = stdin;
54}
55
56/*
57 * Release allocated resources for the given filter.
58 */
59void
61{
62 if (!fstate)
63 return;
64
65 free(fstate->linebuff.data);
66 fstate->linebuff.data = NULL;
67
68 if (fstate->fp && fstate->fp != stdin)
69 {
70 if (fclose(fstate->fp) != 0)
71 pg_log_error("could not close filter file \"%s\": %m", fstate->filename);
72
73 fstate->fp = NULL;
74 }
75}
76
77/*
78 * Translate FilterObjectType enum to string. The main purpose is for error
79 * message formatting.
80 */
81const char *
83{
84 switch (fot)
85 {
87 return "comment or empty line";
89 return "table data";
91 return "table data and children";
93 return "database";
95 return "extension";
97 return "foreign data";
99 return "function";
101 return "index";
103 return "schema";
105 return "table";
107 return "table and children";
109 return "trigger";
110 }
111
112 /* should never get here */
114}
115
116/*
117 * Returns true when keyword is one of supported object types, and
118 * set related objtype. Returns false, when keyword is not assigned
119 * with known object type.
120 */
121static bool
122get_object_type(const char *keyword, int size, FilterObjectType *objtype)
123{
124 if (is_keyword_str("table_data", keyword, size))
126 else if (is_keyword_str("table_data_and_children", keyword, size))
128 else if (is_keyword_str("database", keyword, size))
130 else if (is_keyword_str("extension", keyword, size))
132 else if (is_keyword_str("foreign_data", keyword, size))
134 else if (is_keyword_str("function", keyword, size))
136 else if (is_keyword_str("index", keyword, size))
137 *objtype = FILTER_OBJECT_TYPE_INDEX;
138 else if (is_keyword_str("schema", keyword, size))
139 *objtype = FILTER_OBJECT_TYPE_SCHEMA;
140 else if (is_keyword_str("table", keyword, size))
141 *objtype = FILTER_OBJECT_TYPE_TABLE;
142 else if (is_keyword_str("table_and_children", keyword, size))
144 else if (is_keyword_str("trigger", keyword, size))
146 else
147 return false;
148
149 return true;
150}
151
152
153void
154pg_log_filter_error(FilterStateData *fstate, const char *fmt,...)
155{
156 va_list argp;
157 char buf[256];
158
159 va_start(argp, fmt);
160 vsnprintf(buf, sizeof(buf), fmt, argp);
161 va_end(argp);
162
163 if (fstate->fp == stdin)
164 pg_log_error("invalid format in filter read from standard input on line %d: %s",
165 fstate->lineno, buf);
166 else
167 pg_log_error("invalid format in filter read from file \"%s\" on line %d: %s",
168 fstate->filename, fstate->lineno, buf);
169}
170
171/*
172 * filter_get_keyword - read the next filter keyword from buffer
173 *
174 * Search for keywords (strings of non-whitespace characters) in the passed
175 * in line buffer. Returns NULL when the buffer is empty or no keyword exists.
176 * The length of the found keyword is returned in the size parameter.
177 */
178static const char *
179filter_get_keyword(const char **line, int *size)
180{
181 const char *ptr = *line;
182 const char *result = NULL;
183
184 /* The passed buffer must not be NULL */
185 Assert(*line != NULL);
186
187 /* Set returned length preemptively in case no keyword is found */
188 *size = 0;
189
190 /* Skip initial whitespace */
191 while (isspace((unsigned char) *ptr))
192 ptr++;
193
194 /* Grab one keyword that's the string of non-whitespace characters */
195 if (*ptr != '\0' && !isspace((unsigned char) *ptr))
196 {
197 result = ptr++;
198
199 while (*ptr != '\0' && !isspace((unsigned char) *ptr))
200 ptr++;
201
202 *size = ptr - result;
203 }
204
205 *line = ptr;
206
207 return result;
208}
209
210/*
211 * read_quoted_string - read quoted possibly multi line string
212 *
213 * Reads a quoted string which can span over multiple lines and returns a
214 * pointer to next char after ending double quotes; it will exit on errors.
215 */
216static const char *
218 const char *str,
219 PQExpBuffer pattern)
220{
221 appendPQExpBufferChar(pattern, '"');
222 str++;
223
224 while (1)
225 {
226 /*
227 * We can ignore \r or \n chars because the string is read by
228 * pg_get_line_buf, so these chars should be just trailing chars.
229 */
230 if (*str == '\r' || *str == '\n')
231 {
232 str++;
233 continue;
234 }
235
236 if (*str == '\0')
237 {
238 Assert(fstate->linebuff.data);
239
240 if (!pg_get_line_buf(fstate->fp, &fstate->linebuff))
241 {
242 if (ferror(fstate->fp))
243 pg_log_error("could not read from filter file \"%s\": %m",
244 fstate->filename);
245 else
246 pg_log_filter_error(fstate, _("unexpected end of file"));
247
248 fstate->exit_nicely(1);
249 }
250
251 str = fstate->linebuff.data;
252
253 appendPQExpBufferChar(pattern, '\n');
254 fstate->lineno++;
255 }
256
257 if (*str == '"')
258 {
259 appendPQExpBufferChar(pattern, '"');
260 str++;
261
262 if (*str == '"')
263 {
264 appendPQExpBufferChar(pattern, '"');
265 str++;
266 }
267 else
268 break;
269 }
270 else if (*str == '\\')
271 {
272 str++;
273 if (*str == 'n')
274 appendPQExpBufferChar(pattern, '\n');
275 else if (*str == '\\')
276 appendPQExpBufferChar(pattern, '\\');
277
278 str++;
279 }
280 else
281 appendPQExpBufferChar(pattern, *str++);
282 }
283
284 return str;
285}
286
287/*
288 * read_pattern - reads on object pattern from input
289 *
290 * This function will parse any valid identifier (quoted or not, qualified or
291 * not), which can also includes the full signature for routines.
292 * Note that this function takes special care to sanitize the detected
293 * identifier (removing extraneous whitespaces or other unnecessary
294 * characters). This is necessary as most backup/restore filtering functions
295 * only recognize identifiers if they are written exactly the same way as
296 * they are output by the server.
297 *
298 * Returns a pointer to next character after the found identifier and exits
299 * on error.
300 */
301static const char *
302read_pattern(FilterStateData *fstate, const char *str, PQExpBuffer pattern)
303{
304 bool skip_space = true;
305 bool found_space = false;
306
307 /* Skip initial whitespace */
308 while (isspace((unsigned char) *str))
309 str++;
310
311 if (*str == '\0')
312 {
313 pg_log_filter_error(fstate, _("missing object name pattern"));
314 fstate->exit_nicely(1);
315 }
316
317 while (*str && *str != '#')
318 {
319 while (*str && !isspace((unsigned char) *str) && !strchr("#,.()\"", *str))
320 {
321 /*
322 * Append space only when it is allowed, and when it was found in
323 * original string.
324 */
325 if (!skip_space && found_space)
326 {
327 appendPQExpBufferChar(pattern, ' ');
328 skip_space = true;
329 }
330
331 appendPQExpBufferChar(pattern, *str++);
332 }
333
334 skip_space = false;
335
336 if (*str == '"')
337 {
338 if (found_space)
339 appendPQExpBufferChar(pattern, ' ');
340
341 str = read_quoted_string(fstate, str, pattern);
342 }
343 else if (*str == ',')
344 {
345 appendPQExpBufferStr(pattern, ", ");
346 skip_space = true;
347 str++;
348 }
349 else if (*str && strchr(".()", *str))
350 {
351 appendPQExpBufferChar(pattern, *str++);
352 skip_space = true;
353 }
354
355 found_space = false;
356
357 /* skip ending whitespaces */
358 while (isspace((unsigned char) *str))
359 {
360 found_space = true;
361 str++;
362 }
363 }
364
365 return str;
366}
367
368/*
369 * filter_read_item - Read command/type/pattern triplet from a filter file
370 *
371 * This will parse one filter item from the filter file, and while it is a
372 * row based format a pattern may span more than one line due to how object
373 * names can be constructed. The expected format of the filter file is:
374 *
375 * <command> <object_type> <pattern>
376 *
377 * command can be "include" or "exclude".
378 *
379 * Supported object types are described by enum FilterObjectType
380 * (see function get_object_type).
381 *
382 * pattern can be any possibly-quoted and possibly-qualified identifier. It
383 * follows the same rules as other object include and exclude functions so it
384 * can also use wildcards.
385 *
386 * Returns true when one filter item was successfully read and parsed. When
387 * object name contains \n chars, then more than one line from input file can
388 * be processed. Returns false when the filter file reaches EOF. In case of
389 * error, the function will emit an appropriate error message and exit.
390 */
391bool
393 char **objname,
394 FilterCommandType *comtype,
395 FilterObjectType *objtype)
396{
397 if (pg_get_line_buf(fstate->fp, &fstate->linebuff))
398 {
399 const char *str = fstate->linebuff.data;
400 const char *keyword;
401 int size;
402 PQExpBufferData pattern;
403
404 fstate->lineno++;
405
406 /* Skip initial white spaces */
407 while (isspace((unsigned char) *str))
408 str++;
409
410 /*
411 * Skip empty lines or lines where the first non-whitespace character
412 * is a hash indicating a comment.
413 */
414 if (*str != '\0' && *str != '#')
415 {
416 /*
417 * First we expect sequence of two keywords, {include|exclude}
418 * followed by the object type to operate on.
419 */
420 keyword = filter_get_keyword(&str, &size);
421 if (!keyword)
422 {
423 pg_log_filter_error(fstate,
424 _("no filter command found (expected \"include\" or \"exclude\")"));
425 fstate->exit_nicely(1);
426 }
427
428 if (is_keyword_str("include", keyword, size))
430 else if (is_keyword_str("exclude", keyword, size))
432 else
433 {
434 pg_log_filter_error(fstate,
435 _("invalid filter command (expected \"include\" or \"exclude\")"));
436 fstate->exit_nicely(1);
437 }
438
439 keyword = filter_get_keyword(&str, &size);
440 if (!keyword)
441 {
442 pg_log_filter_error(fstate, _("missing filter object type"));
443 fstate->exit_nicely(1);
444 }
445
446 if (!get_object_type(keyword, size, objtype))
447 {
448 pg_log_filter_error(fstate,
449 _("unsupported filter object type: \"%.*s\""), size, keyword);
450 fstate->exit_nicely(1);
451 }
452
453 initPQExpBuffer(&pattern);
454
455 str = read_pattern(fstate, str, &pattern);
456 *objname = pattern.data;
457 }
458 else
459 {
460 *objname = NULL;
461 *comtype = FILTER_COMMAND_TYPE_NONE;
462 *objtype = FILTER_OBJECT_TYPE_NONE;
463 }
464
465 return true;
466 }
467
468 if (ferror(fstate->fp))
469 {
470 pg_log_error("could not read from filter file \"%s\": %m", fstate->filename);
471 fstate->exit_nicely(1);
472 }
473
474 return false;
475}
#define pg_unreachable()
Definition: c.h:331
#define _(x)
Definition: elog.c:91
static bool get_object_type(const char *keyword, int size, FilterObjectType *objtype)
Definition: filter.c:122
void filter_init(FilterStateData *fstate, const char *filename, exit_function f_exit)
Definition: filter.c:36
void filter_free(FilterStateData *fstate)
Definition: filter.c:60
#define is_keyword_str(cstr, str, bytes)
Definition: filter.c:22
const char * filter_object_type_name(FilterObjectType fot)
Definition: filter.c:82
bool filter_read_item(FilterStateData *fstate, char **objname, FilterCommandType *comtype, FilterObjectType *objtype)
Definition: filter.c:392
void pg_log_filter_error(FilterStateData *fstate, const char *fmt,...)
Definition: filter.c:154
static const char * read_pattern(FilterStateData *fstate, const char *str, PQExpBuffer pattern)
Definition: filter.c:302
static const char * filter_get_keyword(const char **line, int *size)
Definition: filter.c:179
static const char * read_quoted_string(FilterStateData *fstate, const char *str, PQExpBuffer pattern)
Definition: filter.c:217
FilterObjectType
Definition: filter.h:48
@ FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN
Definition: filter.h:51
@ FILTER_OBJECT_TYPE_SCHEMA
Definition: filter.h:57
@ FILTER_OBJECT_TYPE_INDEX
Definition: filter.h:56
@ FILTER_OBJECT_TYPE_TRIGGER
Definition: filter.h:60
@ FILTER_OBJECT_TYPE_FOREIGN_DATA
Definition: filter.h:54
@ FILTER_OBJECT_TYPE_DATABASE
Definition: filter.h:52
@ FILTER_OBJECT_TYPE_FUNCTION
Definition: filter.h:55
@ FILTER_OBJECT_TYPE_TABLE_DATA
Definition: filter.h:50
@ FILTER_OBJECT_TYPE_NONE
Definition: filter.h:49
@ FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN
Definition: filter.h:59
@ FILTER_OBJECT_TYPE_EXTENSION
Definition: filter.h:53
@ FILTER_OBJECT_TYPE_TABLE
Definition: filter.h:58
FilterCommandType
Definition: filter.h:38
@ FILTER_COMMAND_TYPE_NONE
Definition: filter.h:39
@ FILTER_COMMAND_TYPE_EXCLUDE
Definition: filter.h:41
@ FILTER_COMMAND_TYPE_INCLUDE
Definition: filter.h:40
void(* exit_function)(int status)
Definition: filter.h:20
Assert(PointerIsAligned(start, uint64))
const char * str
#define free(a)
Definition: header.h:65
#define pg_log_error(...)
Definition: logging.h:106
static char * filename
Definition: pg_dumpall.c:120
bool pg_get_line_buf(FILE *stream, StringInfo buf)
Definition: pg_get_line.c:95
static char * buf
Definition: pg_test_fsync.c:72
#define vsnprintf
Definition: port.h:238
void initPQExpBuffer(PQExpBuffer str)
Definition: pqexpbuffer.c:90
void appendPQExpBufferChar(PQExpBuffer str, char ch)
Definition: pqexpbuffer.c:378
void appendPQExpBufferStr(PQExpBuffer str, const char *data)
Definition: pqexpbuffer.c:367
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
exit_function exit_nicely
Definition: filter.h:29
StringInfoData linebuff
Definition: filter.h:31
const char * filename
Definition: filter.h:28
FILE * fp
Definition: filter.h:27