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.

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}

free

#define free(a)

Definition: header.h:65

pg_log_error

#define pg_log_error(...)

Definition: logging.h:106

FilterStateData::linebuff

StringInfoData linebuff

Definition: filter.h:31

FilterStateData::filename

const char * filename

Definition: filter.h:28

FilterStateData::fp

FILE * fp

Definition: filter.h:27

StringInfoData::data

char * data

Definition: stringinfo.h:48

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.

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}

Assert

Assert(PointerIsAligned(start, uint64))

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.

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}

filename

static char * filename

Definition: pg_dumpall.c:120

initStringInfo

void initStringInfo(StringInfo str)

Definition: stringinfo.c:97

FilterStateData::exit_nicely

exit_function exit_nicely

Definition: filter.h:29

FilterStateData::lineno

int lineno

Definition: filter.h:30

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.

83{

84 switch (fot)

85 {

86 case FILTER_OBJECT_TYPE_NONE:

87 return "comment or empty line";

88 case FILTER_OBJECT_TYPE_TABLE_DATA:

89 return "table data";

90 case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:

91 return "table data and children";

92 case FILTER_OBJECT_TYPE_DATABASE:

93 return "database";

94 case FILTER_OBJECT_TYPE_EXTENSION:

95 return "extension";

96 case FILTER_OBJECT_TYPE_FOREIGN_DATA:

97 return "foreign data";

98 case FILTER_OBJECT_TYPE_FUNCTION:

99 return "function";

100 case FILTER_OBJECT_TYPE_INDEX:

101 return "index";

102 case FILTER_OBJECT_TYPE_SCHEMA:

103 return "schema";

104 case FILTER_OBJECT_TYPE_TABLE:

105 return "table";

106 case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:

107 return "table and children";

108 case FILTER_OBJECT_TYPE_TRIGGER:

109 return "trigger";

110 }

111

112 /* should never get here */

113 pg_unreachable();

114}

pg_unreachable

#define pg_unreachable()

Definition: c.h:331

FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN

@ FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN

Definition: filter.h:51

FILTER_OBJECT_TYPE_SCHEMA

@ FILTER_OBJECT_TYPE_SCHEMA

Definition: filter.h:57

FILTER_OBJECT_TYPE_INDEX

@ FILTER_OBJECT_TYPE_INDEX

Definition: filter.h:56

FILTER_OBJECT_TYPE_TRIGGER

@ FILTER_OBJECT_TYPE_TRIGGER

Definition: filter.h:60

FILTER_OBJECT_TYPE_FOREIGN_DATA

@ FILTER_OBJECT_TYPE_FOREIGN_DATA

Definition: filter.h:54

FILTER_OBJECT_TYPE_DATABASE

@ FILTER_OBJECT_TYPE_DATABASE

Definition: filter.h:52

FILTER_OBJECT_TYPE_FUNCTION

@ FILTER_OBJECT_TYPE_FUNCTION

Definition: filter.h:55

FILTER_OBJECT_TYPE_TABLE_DATA

@ FILTER_OBJECT_TYPE_TABLE_DATA

Definition: filter.h:50

FILTER_OBJECT_TYPE_NONE

@ FILTER_OBJECT_TYPE_NONE

Definition: filter.h:49

FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN

@ FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN

Definition: filter.h:59

FILTER_OBJECT_TYPE_EXTENSION

@ FILTER_OBJECT_TYPE_EXTENSION

Definition: filter.h:53

FILTER_OBJECT_TYPE_TABLE

@ FILTER_OBJECT_TYPE_TABLE

Definition: filter.h:58

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.

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))

429 *comtype = FILTER_COMMAND_TYPE_INCLUDE;

430 else if (is_keyword_str("exclude", keyword, size))

431 *comtype = FILTER_COMMAND_TYPE_EXCLUDE;

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 _(x)

Definition: elog.c:91

get_object_type

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

Definition: filter.c:122

is_keyword_str

#define is_keyword_str(cstr, str, bytes)

Definition: filter.c:22

pg_log_filter_error

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

Definition: filter.c:154

read_pattern

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

Definition: filter.c:302

filter_get_keyword

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

Definition: filter.c:179

FILTER_COMMAND_TYPE_NONE

@ FILTER_COMMAND_TYPE_NONE

Definition: filter.h:39

FILTER_COMMAND_TYPE_EXCLUDE

@ FILTER_COMMAND_TYPE_EXCLUDE

Definition: filter.h:41

FILTER_COMMAND_TYPE_INCLUDE

@ FILTER_COMMAND_TYPE_INCLUDE

Definition: filter.h:40

str

const char * str

Definition: hashfn_unstable.h:254

pg_get_line_buf

bool pg_get_line_buf(FILE *stream, StringInfo buf)

Definition: pg_get_line.c:95

initPQExpBuffer

void initPQExpBuffer(PQExpBuffer str)

Definition: pqexpbuffer.c:90

PQExpBufferData

Definition: pqexpbuffer.h:45

PQExpBufferData::data

char * data

Definition: pqexpbuffer.h:46

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.

123{

124 if (is_keyword_str("table_data", keyword, size))

125 *objtype = FILTER_OBJECT_TYPE_TABLE_DATA;

126 else if (is_keyword_str("table_data_and_children", keyword, size))

127 *objtype = FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN;

128 else if (is_keyword_str("database", keyword, size))

129 *objtype = FILTER_OBJECT_TYPE_DATABASE;

130 else if (is_keyword_str("extension", keyword, size))

131 *objtype = FILTER_OBJECT_TYPE_EXTENSION;

132 else if (is_keyword_str("foreign_data", keyword, size))

133 *objtype = FILTER_OBJECT_TYPE_FOREIGN_DATA;

134 else if (is_keyword_str("function", keyword, size))

135 *objtype = FILTER_OBJECT_TYPE_FUNCTION;

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))

143 *objtype = FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN;

144 else if (is_keyword_str("trigger", keyword, size))

145 *objtype = FILTER_OBJECT_TYPE_TRIGGER;

146 else

147 return false;

148

149 return true;

150}

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.

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}

buf

static char * buf

Definition: pg_test_fsync.c:72

vsnprintf

#define vsnprintf

Definition: port.h:238

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.

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}

read_quoted_string

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

Definition: filter.c:217

appendPQExpBufferChar

void appendPQExpBufferChar(PQExpBuffer str, char ch)

Definition: pqexpbuffer.c:378

appendPQExpBufferStr

void appendPQExpBufferStr(PQExpBuffer str, const char *data)

Definition: pqexpbuffer.c:367

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.

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}

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().