| 1 |
%top{ |
| 2 |
/* |
| 3 |
* Scanner for the configuration file |
| 4 |
* |
| 5 |
* Copyright (c) 2000-2025, PostgreSQL Global Development Group |
| 6 |
* |
| 7 |
* src/backend/utils/misc/guc-file.l |
| 8 |
*/ |
| 9 |
|
| 10 |
#include "postgres.h" |
| 11 |
|
| 12 |
#include <ctype.h> |
| 13 |
#include <unistd.h> |
| 14 |
|
| 15 |
#include "common/file_utils.h" |
| 16 |
#include "guc_internal.h" |
| 17 |
#include "mb/pg_wchar.h" |
| 18 |
#include "miscadmin.h" |
| 19 |
#include "storage/fd.h" |
| 20 |
#include "utils/conffiles.h" |
| 21 |
#include "utils/memutils.h" |
| 22 |
} |
| 23 |
|
| 24 |
|
| 25 |
%{ |
| 26 |
/* |
| 27 |
* flex emits a yy_fatal_error() function that it calls in response to |
| 28 |
* critical errors like malloc failure, file I/O errors, and detection of |
| 29 |
* internal inconsistency. That function prints a message and calls exit(). |
| 30 |
* Mutate it to instead call our handler, which jumps out of the parser. |
| 31 |
*/ |
| 32 |
#undef fprintf |
| 33 |
#define fprintf(file, fmt, msg) GUC_flex_fatal(msg) |
| 34 |
|
| 35 |
enum |
| 36 |
{ |
| 37 |
GUC_ID = 1, |
| 38 |
GUC_STRING = 2, |
| 39 |
GUC_INTEGER = 3, |
| 40 |
GUC_REAL = 4, |
| 41 |
GUC_EQUALS = 5, |
| 42 |
GUC_UNQUOTED_STRING = 6, |
| 43 |
GUC_QUALIFIED_ID = 7, |
| 44 |
GUC_EOL = 99, |
| 45 |
GUC_ERROR = 100 |
| 46 |
}; |
| 47 |
|
| 48 |
static unsigned int ConfigFileLineno; |
| 49 |
static const char *GUC_flex_fatal_errmsg; |
| 50 |
static sigjmp_buf *GUC_flex_fatal_jmp; |
| 51 |
|
| 52 |
static void FreeConfigVariable(ConfigVariable *item); |
| 53 |
|
| 54 |
static int GUC_flex_fatal(const char *msg); |
| 55 |
|
| 56 |
/* LCOV_EXCL_START */ |
| 57 |
|
| 58 |
%} |
| 59 |
|
| 60 |
%option reentrant |
| 61 |
%option 8bit |
| 62 |
%option never-interactive |
| 63 |
%option nodefault |
| 64 |
%option noinput |
| 65 |
%option nounput |
| 66 |
%option noyywrap |
| 67 |
%option warn |
| 68 |
%option prefix="GUC_yy" |
| 69 |
|
| 70 |
|
| 71 |
SIGN ("-"|"+") |
| 72 |
DIGIT [0-9] |
| 73 |
HEXDIGIT [0-9a-fA-F] |
| 74 |
|
| 75 |
UNIT_LETTER [a-zA-Z] |
| 76 |
|
| 77 |
INTEGER {SIGN}?({DIGIT}+|0x{HEXDIGIT}+){UNIT_LETTER}* |
| 78 |
|
| 79 |
EXPONENT [Ee]{SIGN}?{DIGIT}+ |
| 80 |
REAL {SIGN}?{DIGIT}*"."{DIGIT}*{EXPONENT}? |
| 81 |
|
| 82 |
LETTER [A-Za-z_\200-\377] |
| 83 |
LETTER_OR_DIGIT [A-Za-z_0-9\200-\377] |
| 84 |
|
| 85 |
ID {LETTER}{LETTER_OR_DIGIT}* |
| 86 |
QUALIFIED_ID {ID}"."{ID} |
| 87 |
|
| 88 |
UNQUOTED_STRING {LETTER}({LETTER_OR_DIGIT}|[-._:/])* |
| 89 |
STRING \'([^'\\\n]|\\.|\'\')*\' |
| 90 |
|
| 91 |
%% |
| 92 |
|
| 93 |
\n ConfigFileLineno++; return GUC_EOL; |
| 94 |
[ \t\r]+ /* eat whitespace */ |
| 95 |
#.* /* eat comment (.* matches anything until newline) */ |
| 96 |
|
| 97 |
{ID} return GUC_ID; |
| 98 |
{QUALIFIED_ID} return GUC_QUALIFIED_ID; |
| 99 |
{STRING} return GUC_STRING; |
| 100 |
{UNQUOTED_STRING} return GUC_UNQUOTED_STRING; |
| 101 |
{INTEGER} return GUC_INTEGER; |
| 102 |
{REAL} return GUC_REAL; |
| 103 |
= return GUC_EQUALS; |
| 104 |
|
| 105 |
. return GUC_ERROR; |
| 106 |
|
| 107 |
%% |
| 108 |
|
| 109 |
/* LCOV_EXCL_STOP */ |
| 110 |
|
| 111 |
/* |
| 112 |
* Exported function to read and process the configuration file. The |
| 113 |
* parameter indicates in what context the file is being read --- either |
| 114 |
* postmaster startup (including standalone-backend startup) or SIGHUP. |
| 115 |
* All options mentioned in the configuration file are set to new values. |
| 116 |
* If a hard error occurs, no values will be changed. (There can also be |
| 117 |
* errors that prevent just one value from being changed.) |
| 118 |
*/ |
| 119 |
void |
| 120 |
ProcessConfigFile(GucContext context) |
| 121 |
{ |
| 122 |
int elevel; |
| 123 |
MemoryContext config_cxt; |
| 124 |
MemoryContext caller_cxt; |
| 125 |
|
| 126 |
/* |
| 127 |
* Config files are processed on startup (by the postmaster only) and on |
| 128 |
* SIGHUP (by the postmaster and its children) |
| 129 |
*/ |
| 130 |
Assert((context == PGC_POSTMASTER && !IsUnderPostmaster) || |
| 131 |
context == PGC_SIGHUP); |
| 132 |
|
| 133 |
/* |
| 134 |
* To avoid cluttering the log, only the postmaster bleats loudly about |
| 135 |
* problems with the config file. |
| 136 |
*/ |
| 137 |
elevel = IsUnderPostmaster ? DEBUG2 : LOG; |
| 138 |
|
| 139 |
/* |
| 140 |
* This function is usually called within a process-lifespan memory |
| 141 |
* context. To ensure that any memory leaked during GUC processing does |
| 142 |
* not accumulate across repeated SIGHUP cycles, do the work in a private |
| 143 |
* context that we can free at exit. |
| 144 |
*/ |
| 145 |
config_cxt = AllocSetContextCreate(CurrentMemoryContext, |
| 146 |
"config file processing", |
| 147 |
ALLOCSET_DEFAULT_SIZES); |
| 148 |
caller_cxt = MemoryContextSwitchTo(config_cxt); |
| 149 |
|
| 150 |
/* |
| 151 |
* Read and apply the config file. We don't need to examine the result. |
| 152 |
*/ |
| 153 |
(void) ProcessConfigFileInternal(context, true, elevel); |
| 154 |
|
| 155 |
/* Clean up */ |
| 156 |
MemoryContextSwitchTo(caller_cxt); |
| 157 |
MemoryContextDelete(config_cxt); |
| 158 |
} |
| 159 |
|
| 160 |
/* |
| 161 |
* Read and parse a single configuration file. This function recurses |
| 162 |
* to handle "include" directives. |
| 163 |
* |
| 164 |
* If "strict" is true, treat failure to open the config file as an error, |
| 165 |
* otherwise just skip the file. |
| 166 |
* |
| 167 |
* calling_file/calling_lineno identify the source of the request. |
| 168 |
* Pass NULL/0 if not recursing from an inclusion request. |
| 169 |
* |
| 170 |
* See ParseConfigFp for further details. This one merely adds opening the |
| 171 |
* config file rather than working from a caller-supplied file descriptor, |
| 172 |
* and absolute-ifying the path name if necessary. |
| 173 |
*/ |
| 174 |
bool |
| 175 |
ParseConfigFile(const char *config_file, bool strict, |
| 176 |
const char *calling_file, int calling_lineno, |
| 177 |
int depth, int elevel, |
| 178 |
ConfigVariable **head_p, |
| 179 |
ConfigVariable **tail_p) |
| 180 |
{ |
| 181 |
char *abs_path; |
| 182 |
bool OK = true; |
| 183 |
FILE *fp; |
| 184 |
|
| 185 |
/* |
| 186 |
* Reject file name that is all-blank (including empty), as that leads to |
| 187 |
* confusion --- we'd try to read the containing directory as a file. |
| 188 |
*/ |
| 189 |
if (strspn(config_file, " \t\r\n") == strlen(config_file)) |
| 190 |
{ |
| 191 |
ereport(elevel, |
| 192 |
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| 193 |
errmsg("empty configuration file name: \"%s\"", |
| 194 |
config_file))); |
| 195 |
record_config_file_error("empty configuration file name", |
| 196 |
calling_file, calling_lineno, |
| 197 |
head_p, tail_p); |
| 198 |
return false; |
| 199 |
} |
| 200 |
|
| 201 |
/* |
| 202 |
* Reject too-deep include nesting depth. This is just a safety check to |
| 203 |
* avoid dumping core due to stack overflow if an include file loops back |
| 204 |
* to itself. The maximum nesting depth is pretty arbitrary. |
| 205 |
*/ |
| 206 |
if (depth > CONF_FILE_MAX_DEPTH) |
| 207 |
{ |
| 208 |
ereport(elevel, |
| 209 |
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), |
| 210 |
errmsg("could not open configuration file \"%s\": maximum nesting depth exceeded", |
| 211 |
config_file))); |
| 212 |
record_config_file_error("nesting depth exceeded", |
| 213 |
calling_file, calling_lineno, |
| 214 |
head_p, tail_p); |
| 215 |
return false; |
| 216 |
} |
| 217 |
|
| 218 |
abs_path = AbsoluteConfigLocation(config_file, calling_file); |
| 219 |
|
| 220 |
/* |
| 221 |
* Reject direct recursion. Indirect recursion is also possible, but it's |
| 222 |
* harder to detect and so doesn't seem worth the trouble. (We test at |
| 223 |
* this step because the canonicalization done by AbsoluteConfigLocation |
| 224 |
* makes it more likely that a simple strcmp comparison will match.) |
| 225 |
*/ |
| 226 |
if (calling_file && strcmp(abs_path, calling_file) == 0) |
| 227 |
{ |
| 228 |
ereport(elevel, |
| 229 |
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), |
| 230 |
errmsg("configuration file recursion in \"%s\"", |
| 231 |
calling_file))); |
| 232 |
record_config_file_error("configuration file recursion", |
| 233 |
calling_file, calling_lineno, |
| 234 |
head_p, tail_p); |
| 235 |
pfree(abs_path); |
| 236 |
return false; |
| 237 |
} |
| 238 |
|
| 239 |
fp = AllocateFile(abs_path, "r"); |
| 240 |
if (!fp) |
| 241 |
{ |
| 242 |
if (strict) |
| 243 |
{ |
| 244 |
ereport(elevel, |
| 245 |
(errcode_for_file_access(), |
| 246 |
errmsg("could not open configuration file \"%s\": %m", |
| 247 |
abs_path))); |
| 248 |
record_config_file_error(psprintf("could not open file \"%s\"", |
| 249 |
abs_path), |
| 250 |
calling_file, calling_lineno, |
| 251 |
head_p, tail_p); |
| 252 |
OK = false; |
| 253 |
} |
| 254 |
else |
| 255 |
{ |
| 256 |
ereport(LOG, |
| 257 |
(errmsg("skipping missing configuration file \"%s\"", |
| 258 |
abs_path))); |
| 259 |
} |
| 260 |
goto cleanup; |
| 261 |
} |
| 262 |
|
| 263 |
OK = ParseConfigFp(fp, abs_path, depth, elevel, head_p, tail_p); |
| 264 |
|
| 265 |
cleanup: |
| 266 |
if (fp) |
| 267 |
FreeFile(fp); |
| 268 |
pfree(abs_path); |
| 269 |
|
| 270 |
return OK; |
| 271 |
} |
| 272 |
|
| 273 |
/* |
| 274 |
* Capture an error message in the ConfigVariable list returned by |
| 275 |
* config file parsing. |
| 276 |
*/ |
| 277 |
void |
| 278 |
record_config_file_error(const char *errmsg, |
| 279 |
const char *config_file, |
| 280 |
int lineno, |
| 281 |
ConfigVariable **head_p, |
| 282 |
ConfigVariable **tail_p) |
| 283 |
{ |
| 284 |
ConfigVariable *item; |
| 285 |
|
| 286 |
item = palloc(sizeof *item); |
| 287 |
item->name = NULL; |
| 288 |
item->value = NULL; |
| 289 |
item->errmsg = pstrdup(errmsg); |
| 290 |
item->filename = config_file ? pstrdup(config_file) : NULL; |
| 291 |
item->sourceline = lineno; |
| 292 |
item->ignore = true; |
| 293 |
item->applied = false; |
| 294 |
item->next = NULL; |
| 295 |
if (*head_p == NULL) |
| 296 |
*head_p = item; |
| 297 |
else |
| 298 |
(*tail_p)->next = item; |
| 299 |
*tail_p = item; |
| 300 |
} |
| 301 |
|
| 302 |
/* |
| 303 |
* Flex fatal errors bring us here. Stash the error message and jump back to |
| 304 |
* ParseConfigFp(). Assume all msg arguments point to string constants; this |
| 305 |
* holds for all currently known flex versions. Otherwise, we would need to |
| 306 |
* copy the message. |
| 307 |
* |
| 308 |
* We return "int" since this takes the place of calls to fprintf(). |
| 309 |
*/ |
| 310 |
static int |
| 311 |
GUC_flex_fatal(const char *msg) |
| 312 |
{ |
| 313 |
GUC_flex_fatal_errmsg = msg; |
| 314 |
siglongjmp(*GUC_flex_fatal_jmp, 1); |
| 315 |
return 0; /* keep compiler quiet */ |
| 316 |
} |
| 317 |
|
| 318 |
/* |
| 319 |
* Read and parse a single configuration file. This function recurses |
| 320 |
* to handle "include" directives. |
| 321 |
* |
| 322 |
* Input parameters: |
| 323 |
* fp: file pointer from AllocateFile for the configuration file to parse |
| 324 |
* config_file: absolute or relative path name of the configuration file |
| 325 |
* depth: recursion depth (should be CONF_FILE_START_DEPTH in the outermost |
| 326 |
* call) |
| 327 |
* elevel: error logging level to use |
| 328 |
* Input/Output parameters: |
| 329 |
* head_p, tail_p: head and tail of linked list of name/value pairs |
| 330 |
* |
| 331 |
* *head_p and *tail_p must be initialized, either to NULL or valid pointers |
| 332 |
* to a ConfigVariable list, before calling the outer recursion level. Any |
| 333 |
* name-value pairs read from the input file(s) will be appended to the list. |
| 334 |
* Error reports will also be appended to the list, if elevel < ERROR. |
| 335 |
* |
| 336 |
* Returns TRUE if successful, FALSE if an error occurred. The error has |
| 337 |
* already been ereport'd, it is only necessary for the caller to clean up |
| 338 |
* its own state and release the ConfigVariable list. |
| 339 |
* |
| 340 |
* Note: if elevel >= ERROR then an error will not return control to the |
| 341 |
* caller, so there is no need to check the return value in that case. |
| 342 |
* |
| 343 |
* Note: this function is used to parse not only postgresql.conf, but |
| 344 |
* various other configuration files that use the same "name = value" |
| 345 |
* syntax. Hence, do not do anything here or in the subsidiary routines |
| 346 |
* ParseConfigFile/ParseConfigDirectory that assumes we are processing |
| 347 |
* GUCs specifically. |
| 348 |
*/ |
| 349 |
bool |
| 350 |
ParseConfigFp(FILE *fp, const char *config_file, int depth, int elevel, |
| 351 |
ConfigVariable **head_p, ConfigVariable **tail_p) |
| 352 |
{ |
| 353 |
volatile bool OK = true; |
| 354 |
unsigned int save_ConfigFileLineno = ConfigFileLineno; |
| 355 |
sigjmp_buf *save_GUC_flex_fatal_jmp = GUC_flex_fatal_jmp; |
| 356 |
sigjmp_buf flex_fatal_jmp; |
| 357 |
yyscan_t scanner; |
| 358 |
struct yyguts_t *yyg; /* needed for yytext macro */ |
| 359 |
volatile YY_BUFFER_STATE lex_buffer = NULL; |
| 360 |
int errorcount; |
| 361 |
int token; |
| 362 |
|
| 363 |
if (sigsetjmp(flex_fatal_jmp, 1) == 0) |
| 364 |
GUC_flex_fatal_jmp = &flex_fatal_jmp; |
| 365 |
else |
| 366 |
{ |
| 367 |
/* |
| 368 |
* Regain control after a fatal, internal flex error. It may have |
| 369 |
* corrupted parser state. Consequently, abandon the file, but trust |
| 370 |
* that the state remains sane enough for yy_delete_buffer(). |
| 371 |
*/ |
| 372 |
elog(elevel, "%s at file \"%s\" line %u", |
| 373 |
GUC_flex_fatal_errmsg, config_file, ConfigFileLineno); |
| 374 |
record_config_file_error(GUC_flex_fatal_errmsg, |
| 375 |
config_file, ConfigFileLineno, |
| 376 |
head_p, tail_p); |
| 377 |
OK = false; |
| 378 |
goto cleanup; |
| 379 |
} |
| 380 |
|
| 381 |
/* |
| 382 |
* Parse |
| 383 |
*/ |
| 384 |
ConfigFileLineno = 1; |
| 385 |
errorcount = 0; |
| 386 |
|
| 387 |
if (yylex_init(&scanner) != 0) |
| 388 |
elog(elevel, "yylex_init() failed: %m"); |
| 389 |
yyg = (struct yyguts_t *) scanner; |
| 390 |
|
| 391 |
lex_buffer = yy_create_buffer(fp, YY_BUF_SIZE, scanner); |
| 392 |
yy_switch_to_buffer(lex_buffer, scanner); |
| 393 |
|
| 394 |
/* This loop iterates once per logical line */ |
| 395 |
while ((token = yylex(scanner))) |
| 396 |
{ |
| 397 |
char *opt_name = NULL; |
| 398 |
char *opt_value = NULL; |
| 399 |
ConfigVariable *item; |
| 400 |
|
| 401 |
if (token == GUC_EOL) /* empty or comment line */ |
| 402 |
continue; |
| 403 |
|
| 404 |
/* first token on line is option name */ |
| 405 |
if (token != GUC_ID && token != GUC_QUALIFIED_ID) |
| 406 |
goto parse_error; |
| 407 |
opt_name = pstrdup(yytext); |
| 408 |
|
| 409 |
/* next we have an optional equal sign; discard if present */ |
| 410 |
token = yylex(scanner); |
| 411 |
if (token == GUC_EQUALS) |
| 412 |
token = yylex(scanner); |
| 413 |
|
| 414 |
/* now we must have the option value */ |
| 415 |
if (token != GUC_ID && |
| 416 |
token != GUC_STRING && |
| 417 |
token != GUC_INTEGER && |
| 418 |
token != GUC_REAL && |
| 419 |
token != GUC_UNQUOTED_STRING) |
| 420 |
goto parse_error; |
| 421 |
if (token == GUC_STRING) /* strip quotes and escapes */ |
| 422 |
opt_value = DeescapeQuotedString(yytext); |
| 423 |
else |
| 424 |
opt_value = pstrdup(yytext); |
| 425 |
|
| 426 |
/* now we'd like an end of line, or possibly EOF */ |
| 427 |
token = yylex(scanner); |
| 428 |
if (token != GUC_EOL) |
| 429 |
{ |
| 430 |
if (token != 0) |
| 431 |
goto parse_error; |
| 432 |
/* treat EOF like \n for line numbering purposes, cf bug 4752 */ |
| 433 |
ConfigFileLineno++; |
| 434 |
} |
| 435 |
|
| 436 |
/* OK, process the option name and value */ |
| 437 |
if (guc_name_compare(opt_name, "include_dir") == 0) |
| 438 |
{ |
| 439 |
/* |
| 440 |
* An include_dir directive isn't a variable and should be |
| 441 |
* processed immediately. |
| 442 |
*/ |
| 443 |
if (!ParseConfigDirectory(opt_value, |
| 444 |
config_file, ConfigFileLineno - 1, |
| 445 |
depth + 1, elevel, |
| 446 |
head_p, tail_p)) |
| 447 |
OK = false; |
| 448 |
yy_switch_to_buffer(lex_buffer, scanner); |
| 449 |
pfree(opt_name); |
| 450 |
pfree(opt_value); |
| 451 |
} |
| 452 |
else if (guc_name_compare(opt_name, "include_if_exists") == 0) |
| 453 |
{ |
| 454 |
/* |
| 455 |
* An include_if_exists directive isn't a variable and should be |
| 456 |
* processed immediately. |
| 457 |
*/ |
| 458 |
if (!ParseConfigFile(opt_value, false, |
| 459 |
config_file, ConfigFileLineno - 1, |
| 460 |
depth + 1, elevel, |
| 461 |
head_p, tail_p)) |
| 462 |
OK = false; |
| 463 |
yy_switch_to_buffer(lex_buffer, scanner); |
| 464 |
pfree(opt_name); |
| 465 |
pfree(opt_value); |
| 466 |
} |
| 467 |
else if (guc_name_compare(opt_name, "include") == 0) |
| 468 |
{ |
| 469 |
/* |
| 470 |
* An include directive isn't a variable and should be processed |
| 471 |
* immediately. |
| 472 |
*/ |
| 473 |
if (!ParseConfigFile(opt_value, true, |
| 474 |
config_file, ConfigFileLineno - 1, |
| 475 |
depth + 1, elevel, |
| 476 |
head_p, tail_p)) |
| 477 |
OK = false; |
| 478 |
yy_switch_to_buffer(lex_buffer, scanner); |
| 479 |
pfree(opt_name); |
| 480 |
pfree(opt_value); |
| 481 |
} |
| 482 |
else |
| 483 |
{ |
| 484 |
/* ordinary variable, append to list */ |
| 485 |
item = palloc(sizeof *item); |
| 486 |
item->name = opt_name; |
| 487 |
item->value = opt_value; |
| 488 |
item->errmsg = NULL; |
| 489 |
item->filename = pstrdup(config_file); |
| 490 |
item->sourceline = ConfigFileLineno - 1; |
| 491 |
item->ignore = false; |
| 492 |
item->applied = false; |
| 493 |
item->next = NULL; |
| 494 |
if (*head_p == NULL) |
| 495 |
*head_p = item; |
| 496 |
else |
| 497 |
(*tail_p)->next = item; |
| 498 |
*tail_p = item; |
| 499 |
} |
| 500 |
|
| 501 |
/* break out of loop if read EOF, else loop for next line */ |
| 502 |
if (token == 0) |
| 503 |
break; |
| 504 |
continue; |
| 505 |
|
| 506 |
parse_error: |
| 507 |
/* release storage if we allocated any on this line */ |
| 508 |
if (opt_name) |
| 509 |
pfree(opt_name); |
| 510 |
if (opt_value) |
| 511 |
pfree(opt_value); |
| 512 |
|
| 513 |
/* report the error */ |
| 514 |
if (token == GUC_EOL || token == 0) |
| 515 |
{ |
| 516 |
ereport(elevel, |
| 517 |
(errcode(ERRCODE_SYNTAX_ERROR), |
| 518 |
errmsg("syntax error in file \"%s\" line %u, near end of line", |
| 519 |
config_file, ConfigFileLineno - 1))); |
| 520 |
record_config_file_error("syntax error", |
| 521 |
config_file, ConfigFileLineno - 1, |
| 522 |
head_p, tail_p); |
| 523 |
} |
| 524 |
else |
| 525 |
{ |
| 526 |
ereport(elevel, |
| 527 |
(errcode(ERRCODE_SYNTAX_ERROR), |
| 528 |
errmsg("syntax error in file \"%s\" line %u, near token \"%s\"", |
| 529 |
config_file, ConfigFileLineno, yytext))); |
| 530 |
record_config_file_error("syntax error", |
| 531 |
config_file, ConfigFileLineno, |
| 532 |
head_p, tail_p); |
| 533 |
} |
| 534 |
OK = false; |
| 535 |
errorcount++; |
| 536 |
|
| 537 |
/* |
| 538 |
* To avoid producing too much noise when fed a totally bogus file, |
| 539 |
* give up after 100 syntax errors per file (an arbitrary number). |
| 540 |
* Also, if we're only logging the errors at DEBUG level anyway, might |
| 541 |
* as well give up immediately. (This prevents postmaster children |
| 542 |
* from bloating the logs with duplicate complaints.) |
| 543 |
*/ |
| 544 |
if (errorcount >= 100 || elevel <= DEBUG1) |
| 545 |
{ |
| 546 |
ereport(elevel, |
| 547 |
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), |
| 548 |
errmsg("too many syntax errors found, abandoning file \"%s\"", |
| 549 |
config_file))); |
| 550 |
break; |
| 551 |
} |
| 552 |
|
| 553 |
/* resync to next end-of-line or EOF */ |
| 554 |
while (token != GUC_EOL && token != 0) |
| 555 |
token = yylex(scanner); |
| 556 |
/* break out of loop on EOF */ |
| 557 |
if (token == 0) |
| 558 |
break; |
| 559 |
} |
| 560 |
|
| 561 |
cleanup: |
| 562 |
yy_delete_buffer(lex_buffer, scanner); |
| 563 |
yylex_destroy(scanner); |
| 564 |
/* Each recursion level must save and restore these static variables. */ |
| 565 |
ConfigFileLineno = save_ConfigFileLineno; |
| 566 |
GUC_flex_fatal_jmp = save_GUC_flex_fatal_jmp; |
| 567 |
return OK; |
| 568 |
} |
| 569 |
|
| 570 |
/* |
| 571 |
* Read and parse all config files in a subdirectory in alphabetical order |
| 572 |
* |
| 573 |
* includedir is the absolute or relative path to the subdirectory to scan. |
| 574 |
* |
| 575 |
* calling_file/calling_lineno identify the source of the request. |
| 576 |
* Pass NULL/0 if not recursing from an inclusion request. |
| 577 |
* |
| 578 |
* See ParseConfigFp for further details. |
| 579 |
*/ |
| 580 |
bool |
| 581 |
ParseConfigDirectory(const char *includedir, |
| 582 |
const char *calling_file, int calling_lineno, |
| 583 |
int depth, int elevel, |
| 584 |
ConfigVariable **head_p, |
| 585 |
ConfigVariable **tail_p) |
| 586 |
{ |
| 587 |
char *err_msg; |
| 588 |
char **filenames; |
| 589 |
int num_filenames; |
| 590 |
|
| 591 |
filenames = GetConfFilesInDir(includedir, calling_file, elevel, |
| 592 |
&num_filenames, &err_msg); |
| 593 |
|
| 594 |
if (!filenames) |
| 595 |
{ |
| 596 |
record_config_file_error(err_msg, calling_file, calling_lineno, head_p, |
| 597 |
tail_p); |
| 598 |
return false; |
| 599 |
} |
| 600 |
|
| 601 |
for (int i = 0; i < num_filenames; i++) |
| 602 |
{ |
| 603 |
if (!ParseConfigFile(filenames[i], true, |
| 604 |
calling_file, calling_lineno, |
| 605 |
depth, elevel, |
| 606 |
head_p, tail_p)) |
| 607 |
return false; |
| 608 |
} |
| 609 |
|
| 610 |
return true; |
| 611 |
} |
| 612 |
|
| 613 |
/* |
| 614 |
* Free a list of ConfigVariables, including the names and the values |
| 615 |
*/ |
| 616 |
void |
| 617 |
FreeConfigVariables(ConfigVariable *list) |
| 618 |
{ |
| 619 |
ConfigVariable *item; |
| 620 |
|
| 621 |
item = list; |
| 622 |
while (item) |
| 623 |
{ |
| 624 |
ConfigVariable *next = item->next; |
| 625 |
|
| 626 |
FreeConfigVariable(item); |
| 627 |
item = next; |
| 628 |
} |
| 629 |
} |
| 630 |
|
| 631 |
/* |
| 632 |
* Free a single ConfigVariable |
| 633 |
*/ |
| 634 |
static void |
| 635 |
FreeConfigVariable(ConfigVariable *item) |
| 636 |
{ |
| 637 |
if (item->name) |
| 638 |
pfree(item->name); |
| 639 |
if (item->value) |
| 640 |
pfree(item->value); |
| 641 |
if (item->errmsg) |
| 642 |
pfree(item->errmsg); |
| 643 |
if (item->filename) |
| 644 |
pfree(item->filename); |
| 645 |
pfree(item); |
| 646 |
} |
| 647 |
|
| 648 |
|
| 649 |
/* |
| 650 |
* DeescapeQuotedString |
| 651 |
* |
| 652 |
* Strip the quotes surrounding the given string, and collapse any embedded |
| 653 |
* '' sequences and backslash escapes. |
| 654 |
* |
| 655 |
* The string returned is palloc'd and should eventually be pfree'd by the |
| 656 |
* caller. |
| 657 |
* |
| 658 |
* This is exported because it is also used by the bootstrap scanner. |
| 659 |
*/ |
| 660 |
char * |
| 661 |
DeescapeQuotedString(const char *s) |
| 662 |
{ |
| 663 |
char *newStr; |
| 664 |
int len, |
| 665 |
i, |
| 666 |
j; |
| 667 |
|
| 668 |
/* We just Assert that there are leading and trailing quotes */ |
| 669 |
Assert(s != NULL && s[0] == '\''); |
| 670 |
len = strlen(s); |
| 671 |
Assert(len >= 2); |
| 672 |
Assert(s[len - 1] == '\''); |
| 673 |
|
| 674 |
/* Skip the leading quote; we'll handle the trailing quote below */ |
| 675 |
s++, len--; |
| 676 |
|
| 677 |
/* Since len still includes trailing quote, this is enough space */ |
| 678 |
newStr = palloc(len); |
| 679 |
|
| 680 |
for (i = 0, j = 0; i < len; i++) |
| 681 |
{ |
| 682 |
if (s[i] == '\\') |
| 683 |
{ |
| 684 |
i++; |
| 685 |
switch (s[i]) |
| 686 |
{ |
| 687 |
case 'b': |
| 688 |
newStr[j] = '\b'; |
| 689 |
break; |
| 690 |
case 'f': |
| 691 |
newStr[j] = '\f'; |
| 692 |
break; |
| 693 |
case 'n': |
| 694 |
newStr[j] = '\n'; |
| 695 |
break; |
| 696 |
case 'r': |
| 697 |
newStr[j] = '\r'; |
| 698 |
break; |
| 699 |
case 't': |
| 700 |
newStr[j] = '\t'; |
| 701 |
break; |
| 702 |
case '0': |
| 703 |
case '1': |
| 704 |
case '2': |
| 705 |
case '3': |
| 706 |
case '4': |
| 707 |
case '5': |
| 708 |
case '6': |
| 709 |
case '7': |
| 710 |
{ |
| 711 |
int k; |
| 712 |
long octVal = 0; |
| 713 |
|
| 714 |
for (k = 0; |
| 715 |
s[i + k] >= '0' && s[i + k] <= '7' && k < 3; |
| 716 |
k++) |
| 717 |
octVal = (octVal << 3) + (s[i + k] - '0'); |
| 718 |
i += k - 1; |
| 719 |
newStr[j] = ((char) octVal); |
| 720 |
} |
| 721 |
break; |
| 722 |
default: |
| 723 |
newStr[j] = s[i]; |
| 724 |
break; |
| 725 |
} /* switch */ |
| 726 |
} |
| 727 |
else if (s[i] == '\'' && s[i + 1] == '\'') |
| 728 |
{ |
| 729 |
/* doubled quote becomes just one quote */ |
| 730 |
newStr[j] = s[++i]; |
| 731 |
} |
| 732 |
else |
| 733 |
newStr[j] = s[i]; |
| 734 |
j++; |
| 735 |
} |
| 736 |
|
| 737 |
/* We copied the ending quote to newStr, so replace with \0 */ |
| 738 |
Assert(j > 0 && j <= len); |
| 739 |
newStr[--j] = '\0'; |
| 740 |
|
| 741 |
return newStr; |
| 742 |
} |