Line data Source code
1 : /*
2 : * psql - the PostgreSQL interactive terminal
3 : *
4 : * Copyright (c) 2000-2021, PostgreSQL Global Development Group
5 : *
6 : * src/bin/psql/startup.c
7 : */
8 : #include "postgres_fe.h"
9 :
10 : #ifndef WIN32
11 : #include <unistd.h>
12 : #else /* WIN32 */
13 : #include <io.h>
14 : #include <win32.h>
15 : #endif /* WIN32 */
16 :
17 : #include "command.h"
18 : #include "common.h"
19 : #include "common/logging.h"
20 : #include "common/string.h"
21 : #include "describe.h"
22 : #include "fe_utils/print.h"
23 : #include "getopt_long.h"
24 : #include "help.h"
25 : #include "input.h"
26 : #include "mainloop.h"
27 : #include "settings.h"
28 :
29 : /*
30 : * Global psql options
31 : */
32 : PsqlSettings pset;
33 :
34 : #ifndef WIN32
35 : #define SYSPSQLRC "psqlrc"
36 : #define PSQLRC ".psqlrc"
37 : #else
38 : #define SYSPSQLRC "psqlrc"
39 : #define PSQLRC "psqlrc.conf"
40 : #endif
41 :
42 : /*
43 : * Structures to pass information between the option parsing routine
44 : * and the main function
45 : */
46 : enum _actions
47 : {
48 : ACT_SINGLE_QUERY,
49 : ACT_SINGLE_SLASH,
50 : ACT_FILE
51 : };
52 :
53 : typedef struct SimpleActionListCell
54 : {
55 : struct SimpleActionListCell *next;
56 : enum _actions action;
57 : char *val;
58 : } SimpleActionListCell;
59 :
60 : typedef struct SimpleActionList
61 : {
62 : SimpleActionListCell *head;
63 : SimpleActionListCell *tail;
64 : } SimpleActionList;
65 :
66 : struct adhoc_opts
67 : {
68 : char *dbname;
69 : char *host;
70 : char *port;
71 : char *username;
72 : char *logfilename;
73 : bool no_readline;
74 : bool no_psqlrc;
75 : bool single_txn;
76 : bool list_dbs;
77 : SimpleActionList actions;
78 : };
79 :
80 : static void parse_psql_options(int argc, char *argv[],
81 : struct adhoc_opts *options);
82 : static void simple_action_list_append(SimpleActionList *list,
83 : enum _actions action, const char *val);
84 : static void process_psqlrc(char *argv0);
85 : static void process_psqlrc_file(char *filename);
86 : static void showVersion(void);
87 : static void EstablishVariableSpace(void);
88 :
89 : #define NOPAGER 0
90 :
91 : static void
92 30826 : log_pre_callback(void)
93 : {
94 30826 : if (pset.queryFout && pset.queryFout != stdout)
95 0 : fflush(pset.queryFout);
96 30826 : }
97 :
98 : static void
99 30826 : log_locus_callback(const char **filename, uint64 *lineno)
100 : {
101 30826 : if (pset.inputfile)
102 : {
103 348 : *filename = pset.inputfile;
104 348 : *lineno = pset.lineno;
105 : }
106 : else
107 : {
108 30478 : *filename = NULL;
109 30478 : *lineno = 0;
110 : }
111 30826 : }
112 :
113 : /*
114 : *
115 : * main
116 : *
117 : */
118 : int
119 6028 : main(int argc, char *argv[])
120 : {
121 : struct adhoc_opts options;
122 : int successResult;
123 6028 : char *password = NULL;
124 : bool new_pass;
125 :
126 6028 : pg_logging_init(argv[0]);
127 6028 : pg_logging_set_pre_callback(log_pre_callback);
128 6028 : pg_logging_set_locus_callback(log_locus_callback);
129 6028 : set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("psql"));
130 :
131 6028 : if (argc > 1)
132 : {
133 6028 : if ((strcmp(argv[1], "-?") == 0) || (argc == 2 && (strcmp(argv[1], "--help") == 0)))
134 : {
135 0 : usage(NOPAGER);
136 0 : exit(EXIT_SUCCESS);
137 : }
138 6028 : if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
139 : {
140 0 : showVersion();
141 0 : exit(EXIT_SUCCESS);
142 : }
143 : }
144 :
145 6028 : pset.progname = get_progname(argv[0]);
146 :
147 6028 : pset.db = NULL;
148 6028 : pset.dead_conn = NULL;
149 6028 : setDecimalLocale();
150 6028 : pset.encoding = PQenv2encoding();
151 6028 : pset.queryFout = stdout;
152 6028 : pset.queryFoutPipe = false;
153 6028 : pset.copyStream = NULL;
154 6028 : pset.last_error_result = NULL;
155 6028 : pset.cur_cmd_source = stdin;
156 6028 : pset.cur_cmd_interactive = false;
157 :
158 : /* We rely on unmentioned fields of pset.popt to start out 0/false/NULL */
159 6028 : pset.popt.topt.format = PRINT_ALIGNED;
160 6028 : pset.popt.topt.border = 1;
161 6028 : pset.popt.topt.pager = 1;
162 6028 : pset.popt.topt.pager_min_lines = 0;
163 6028 : pset.popt.topt.start_table = true;
164 6028 : pset.popt.topt.stop_table = true;
165 6028 : pset.popt.topt.default_footer = true;
166 :
167 6028 : pset.popt.topt.csvFieldSep[0] = DEFAULT_CSV_FIELD_SEP;
168 6028 : pset.popt.topt.csvFieldSep[1] = '\0';
169 :
170 6028 : pset.popt.topt.unicode_border_linestyle = UNICODE_LINESTYLE_SINGLE;
171 6028 : pset.popt.topt.unicode_column_linestyle = UNICODE_LINESTYLE_SINGLE;
172 6028 : pset.popt.topt.unicode_header_linestyle = UNICODE_LINESTYLE_SINGLE;
173 :
174 6028 : refresh_utf8format(&(pset.popt.topt));
175 :
176 : /* We must get COLUMNS here before readline() sets it */
177 6028 : pset.popt.topt.env_columns = getenv("COLUMNS") ? atoi(getenv("COLUMNS")) : 0;
178 :
179 6028 : pset.notty = (!isatty(fileno(stdin)) || !isatty(fileno(stdout)));
180 :
181 6028 : pset.getPassword = TRI_DEFAULT;
182 :
183 6028 : EstablishVariableSpace();
184 :
185 : /* Create variables showing psql version number */
186 6028 : SetVariable(pset.vars, "VERSION", PG_VERSION_STR);
187 6028 : SetVariable(pset.vars, "VERSION_NAME", PG_VERSION);
188 6028 : SetVariable(pset.vars, "VERSION_NUM", CppAsString2(PG_VERSION_NUM));
189 :
190 : /* Initialize variables for last error */
191 6028 : SetVariable(pset.vars, "LAST_ERROR_MESSAGE", "");
192 6028 : SetVariable(pset.vars, "LAST_ERROR_SQLSTATE", "00000");
193 :
194 : /* Default values for variables (that don't match the result of \unset) */
195 6028 : SetVariableBool(pset.vars, "AUTOCOMMIT");
196 6028 : SetVariable(pset.vars, "PROMPT1", DEFAULT_PROMPT1);
197 6028 : SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
198 6028 : SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);
199 :
200 6028 : parse_psql_options(argc, argv, &options);
201 :
202 : /*
203 : * If no action was specified and we're in non-interactive mode, treat it
204 : * as if the user had specified "-f -". This lets single-transaction mode
205 : * work in this case.
206 : */
207 6028 : if (options.actions.head == NULL && pset.notty)
208 1728 : simple_action_list_append(&options.actions, ACT_FILE, NULL);
209 :
210 : /* Bail out if -1 was specified but will be ignored. */
211 6028 : if (options.single_txn && options.actions.head == NULL)
212 : {
213 0 : pg_log_fatal("-1 can only be used in non-interactive mode");
214 0 : exit(EXIT_FAILURE);
215 : }
216 :
217 6028 : if (!pset.popt.topt.fieldSep.separator &&
218 6024 : !pset.popt.topt.fieldSep.separator_zero)
219 : {
220 6024 : pset.popt.topt.fieldSep.separator = pg_strdup(DEFAULT_FIELD_SEP);
221 6024 : pset.popt.topt.fieldSep.separator_zero = false;
222 : }
223 6028 : if (!pset.popt.topt.recordSep.separator &&
224 6028 : !pset.popt.topt.recordSep.separator_zero)
225 : {
226 6028 : pset.popt.topt.recordSep.separator = pg_strdup(DEFAULT_RECORD_SEP);
227 6028 : pset.popt.topt.recordSep.separator_zero = false;
228 : }
229 :
230 6028 : if (pset.getPassword == TRI_YES)
231 : {
232 : /*
233 : * We can't be sure yet of the username that will be used, so don't
234 : * offer a potentially wrong one. Typical uses of this option are
235 : * noninteractive anyway.
236 : */
237 0 : password = simple_prompt("Password: ", false);
238 : }
239 :
240 : /* loop until we have a password if requested by backend */
241 : do
242 : {
243 : #define PARAMS_ARRAY_SIZE 8
244 6028 : const char **keywords = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
245 6028 : const char **values = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
246 :
247 6028 : keywords[0] = "host";
248 6028 : values[0] = options.host;
249 6028 : keywords[1] = "port";
250 6028 : values[1] = options.port;
251 6028 : keywords[2] = "user";
252 6028 : values[2] = options.username;
253 6028 : keywords[3] = "password";
254 6028 : values[3] = password;
255 6028 : keywords[4] = "dbname"; /* see do_connect() */
256 0 : values[4] = (options.list_dbs && options.dbname == NULL) ?
257 6028 : "postgres" : options.dbname;
258 6028 : keywords[5] = "fallback_application_name";
259 6028 : values[5] = pset.progname;
260 6028 : keywords[6] = "client_encoding";
261 6028 : values[6] = (pset.notty || getenv("PGCLIENTENCODING")) ? NULL : "auto";
262 6028 : keywords[7] = NULL;
263 6028 : values[7] = NULL;
264 :
265 6028 : new_pass = false;
266 6028 : pset.db = PQconnectdbParams(keywords, values, true);
267 6028 : free(keywords);
268 6028 : free(values);
269 :
270 6408 : if (PQstatus(pset.db) == CONNECTION_BAD &&
271 382 : PQconnectionNeedsPassword(pset.db) &&
272 2 : !password &&
273 2 : pset.getPassword != TRI_NO)
274 : {
275 : /*
276 : * Before closing the old PGconn, extract the user name that was
277 : * actually connected with --- it might've come out of a URI or
278 : * connstring "database name" rather than options.username.
279 : */
280 0 : const char *realusername = PQuser(pset.db);
281 : char *password_prompt;
282 :
283 0 : if (realusername && realusername[0])
284 0 : password_prompt = psprintf(_("Password for user %s: "),
285 : realusername);
286 : else
287 0 : password_prompt = pg_strdup(_("Password: "));
288 0 : PQfinish(pset.db);
289 :
290 0 : password = simple_prompt(password_prompt, false);
291 0 : free(password_prompt);
292 0 : new_pass = true;
293 : }
294 6028 : } while (new_pass);
295 :
296 6028 : if (PQstatus(pset.db) == CONNECTION_BAD)
297 : {
298 380 : pg_log_error("%s", PQerrorMessage(pset.db));
299 380 : PQfinish(pset.db);
300 380 : exit(EXIT_BADCONN);
301 : }
302 :
303 5648 : psql_setup_cancel_handler();
304 :
305 5648 : PQsetNoticeProcessor(pset.db, NoticeProcessor, NULL);
306 :
307 5648 : SyncVariables();
308 :
309 5648 : if (options.list_dbs)
310 : {
311 : int success;
312 :
313 0 : if (!options.no_psqlrc)
314 0 : process_psqlrc(argv[0]);
315 :
316 0 : success = listAllDbs(NULL, false);
317 0 : PQfinish(pset.db);
318 0 : exit(success ? EXIT_SUCCESS : EXIT_FAILURE);
319 : }
320 :
321 5648 : if (options.logfilename)
322 : {
323 0 : pset.logfile = fopen(options.logfilename, "a");
324 0 : if (!pset.logfile)
325 : {
326 0 : pg_log_fatal("could not open log file \"%s\": %m",
327 : options.logfilename);
328 0 : exit(EXIT_FAILURE);
329 : }
330 : }
331 :
332 5648 : if (!options.no_psqlrc)
333 0 : process_psqlrc(argv[0]);
334 :
335 : /*
336 : * If any actions were given by user, process them in the order in which
337 : * they were specified. Note single_txn is only effective in this mode.
338 : */
339 5648 : if (options.actions.head != NULL)
340 : {
341 : PGresult *res;
342 : SimpleActionListCell *cell;
343 :
344 5646 : successResult = EXIT_SUCCESS; /* silence compiler */
345 :
346 5646 : if (options.single_txn)
347 : {
348 0 : if ((res = PSQLexec("BEGIN")) == NULL)
349 : {
350 0 : if (pset.on_error_stop)
351 : {
352 0 : successResult = EXIT_USER;
353 0 : goto error;
354 : }
355 : }
356 : else
357 0 : PQclear(res);
358 : }
359 :
360 11274 : for (cell = options.actions.head; cell; cell = cell->next)
361 : {
362 5670 : if (cell->action == ACT_SINGLE_QUERY)
363 : {
364 1684 : pg_logging_config(PG_LOG_FLAG_TERSE);
365 :
366 1684 : if (pset.echo == PSQL_ECHO_ALL)
367 0 : puts(cell->val);
368 :
369 1684 : successResult = SendQuery(cell->val)
370 1682 : ? EXIT_SUCCESS : EXIT_FAILURE;
371 : }
372 3986 : else if (cell->action == ACT_SINGLE_SLASH)
373 : {
374 : PsqlScanState scan_state;
375 : ConditionalStack cond_stack;
376 :
377 0 : pg_logging_config(PG_LOG_FLAG_TERSE);
378 :
379 0 : if (pset.echo == PSQL_ECHO_ALL)
380 0 : puts(cell->val);
381 :
382 0 : scan_state = psql_scan_create(&psqlscan_callbacks);
383 0 : psql_scan_setup(scan_state,
384 0 : cell->val, strlen(cell->val),
385 0 : pset.encoding, standard_strings());
386 0 : cond_stack = conditional_stack_create();
387 0 : psql_scan_set_passthrough(scan_state, (void *) cond_stack);
388 :
389 0 : successResult = HandleSlashCmds(scan_state,
390 : cond_stack,
391 : NULL,
392 : NULL) != PSQL_CMD_ERROR
393 0 : ? EXIT_SUCCESS : EXIT_FAILURE;
394 :
395 0 : psql_scan_destroy(scan_state);
396 0 : conditional_stack_destroy(cond_stack);
397 : }
398 3986 : else if (cell->action == ACT_FILE)
399 : {
400 3986 : successResult = process_file(cell->val, false);
401 : }
402 : else
403 : {
404 : /* should never come here */
405 : Assert(false);
406 : }
407 :
408 5660 : if (successResult != EXIT_SUCCESS && pset.on_error_stop)
409 32 : break;
410 : }
411 :
412 5636 : if (options.single_txn)
413 : {
414 0 : if ((res = PSQLexec("COMMIT")) == NULL)
415 : {
416 0 : if (pset.on_error_stop)
417 : {
418 0 : successResult = EXIT_USER;
419 0 : goto error;
420 : }
421 : }
422 : else
423 0 : PQclear(res);
424 : }
425 :
426 5636 : error:
427 : ;
428 : }
429 :
430 : /*
431 : * or otherwise enter interactive main loop
432 : */
433 : else
434 : {
435 2 : pg_logging_config(PG_LOG_FLAG_TERSE);
436 2 : connection_warnings(true);
437 2 : if (!pset.quiet)
438 2 : printf(_("Type \"help\" for help.\n\n"));
439 2 : initializeInput(options.no_readline ? 0 : 1);
440 2 : successResult = MainLoop(stdin);
441 : }
442 :
443 : /* clean up */
444 5638 : if (pset.logfile)
445 0 : fclose(pset.logfile);
446 5638 : if (pset.db)
447 5638 : PQfinish(pset.db);
448 5638 : if (pset.dead_conn)
449 0 : PQfinish(pset.dead_conn);
450 5638 : setQFout(NULL);
451 :
452 5638 : return successResult;
453 : }
454 :
455 :
456 : /*
457 : * Parse command line options
458 : */
459 :
460 : static void
461 6028 : parse_psql_options(int argc, char *argv[], struct adhoc_opts *options)
462 : {
463 : static struct option long_options[] =
464 : {
465 : {"echo-all", no_argument, NULL, 'a'},
466 : {"no-align", no_argument, NULL, 'A'},
467 : {"command", required_argument, NULL, 'c'},
468 : {"dbname", required_argument, NULL, 'd'},
469 : {"echo-queries", no_argument, NULL, 'e'},
470 : {"echo-errors", no_argument, NULL, 'b'},
471 : {"echo-hidden", no_argument, NULL, 'E'},
472 : {"file", required_argument, NULL, 'f'},
473 : {"field-separator", required_argument, NULL, 'F'},
474 : {"field-separator-zero", no_argument, NULL, 'z'},
475 : {"host", required_argument, NULL, 'h'},
476 : {"html", no_argument, NULL, 'H'},
477 : {"list", no_argument, NULL, 'l'},
478 : {"log-file", required_argument, NULL, 'L'},
479 : {"no-readline", no_argument, NULL, 'n'},
480 : {"single-transaction", no_argument, NULL, '1'},
481 : {"output", required_argument, NULL, 'o'},
482 : {"port", required_argument, NULL, 'p'},
483 : {"pset", required_argument, NULL, 'P'},
484 : {"quiet", no_argument, NULL, 'q'},
485 : {"record-separator", required_argument, NULL, 'R'},
486 : {"record-separator-zero", no_argument, NULL, '0'},
487 : {"single-step", no_argument, NULL, 's'},
488 : {"single-line", no_argument, NULL, 'S'},
489 : {"tuples-only", no_argument, NULL, 't'},
490 : {"table-attr", required_argument, NULL, 'T'},
491 : {"username", required_argument, NULL, 'U'},
492 : {"set", required_argument, NULL, 'v'},
493 : {"variable", required_argument, NULL, 'v'},
494 : {"version", no_argument, NULL, 'V'},
495 : {"no-password", no_argument, NULL, 'w'},
496 : {"password", no_argument, NULL, 'W'},
497 : {"expanded", no_argument, NULL, 'x'},
498 : {"no-psqlrc", no_argument, NULL, 'X'},
499 : {"help", optional_argument, NULL, 1},
500 : {"csv", no_argument, NULL, 2},
501 : {NULL, 0, NULL, 0}
502 : };
503 :
504 : int optindex;
505 : int c;
506 :
507 6028 : memset(options, 0, sizeof *options);
508 :
509 38614 : while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",
510 : long_options, &optindex)) != -1)
511 : {
512 32586 : switch (c)
513 : {
514 1306 : case 'a':
515 1306 : SetVariable(pset.vars, "ECHO", "all");
516 1306 : break;
517 3756 : case 'A':
518 3756 : pset.popt.topt.format = PRINT_UNALIGNED;
519 3756 : break;
520 0 : case 'b':
521 0 : SetVariable(pset.vars, "ECHO", "errors");
522 0 : break;
523 1766 : case 'c':
524 1766 : if (optarg[0] == '\\')
525 0 : simple_action_list_append(&options->actions,
526 : ACT_SINGLE_SLASH,
527 0 : optarg + 1);
528 : else
529 1766 : simple_action_list_append(&options->actions,
530 : ACT_SINGLE_QUERY,
531 : optarg);
532 1766 : break;
533 5284 : case 'd':
534 5284 : options->dbname = pg_strdup(optarg);
535 5284 : break;
536 2 : case 'e':
537 2 : SetVariable(pset.vars, "ECHO", "queries");
538 2 : break;
539 0 : case 'E':
540 0 : SetVariableBool(pset.vars, "ECHO_HIDDEN");
541 0 : break;
542 2576 : case 'f':
543 2576 : simple_action_list_append(&options->actions,
544 : ACT_FILE,
545 : optarg);
546 2576 : break;
547 4 : case 'F':
548 4 : pset.popt.topt.fieldSep.separator = pg_strdup(optarg);
549 4 : pset.popt.topt.fieldSep.separator_zero = false;
550 4 : break;
551 2 : case 'h':
552 2 : options->host = pg_strdup(optarg);
553 2 : break;
554 0 : case 'H':
555 0 : pset.popt.topt.format = PRINT_HTML;
556 0 : break;
557 0 : case 'l':
558 0 : options->list_dbs = true;
559 0 : break;
560 0 : case 'L':
561 0 : options->logfilename = pg_strdup(optarg);
562 0 : break;
563 0 : case 'n':
564 0 : options->no_readline = true;
565 0 : break;
566 0 : case 'o':
567 0 : if (!setQFout(optarg))
568 0 : exit(EXIT_FAILURE);
569 0 : break;
570 4 : case 'p':
571 4 : options->port = pg_strdup(optarg);
572 4 : break;
573 4 : case 'P':
574 : {
575 : char *value;
576 : char *equal_loc;
577 : bool result;
578 :
579 4 : value = pg_strdup(optarg);
580 4 : equal_loc = strchr(value, '=');
581 4 : if (!equal_loc)
582 0 : result = do_pset(value, NULL, &pset.popt, true);
583 : else
584 : {
585 4 : *equal_loc = '\0';
586 4 : result = do_pset(value, equal_loc + 1, &pset.popt, true);
587 : }
588 :
589 4 : if (!result)
590 : {
591 0 : pg_log_fatal("could not set printing parameter \"%s\"", value);
592 0 : exit(EXIT_FAILURE);
593 : }
594 :
595 4 : free(value);
596 4 : break;
597 : }
598 4110 : case 'q':
599 4110 : SetVariableBool(pset.vars, "QUIET");
600 4110 : break;
601 0 : case 'R':
602 0 : pset.popt.topt.recordSep.separator = pg_strdup(optarg);
603 0 : pset.popt.topt.recordSep.separator_zero = false;
604 0 : break;
605 0 : case 's':
606 0 : SetVariableBool(pset.vars, "SINGLESTEP");
607 0 : break;
608 0 : case 'S':
609 0 : SetVariableBool(pset.vars, "SINGLELINE");
610 0 : break;
611 3748 : case 't':
612 3748 : pset.popt.topt.tuples_only = true;
613 3748 : break;
614 0 : case 'T':
615 0 : pset.popt.topt.tableAttr = pg_strdup(optarg);
616 0 : break;
617 100 : case 'U':
618 100 : options->username = pg_strdup(optarg);
619 100 : break;
620 3870 : case 'v':
621 : {
622 : char *value;
623 : char *equal_loc;
624 :
625 3870 : value = pg_strdup(optarg);
626 3870 : equal_loc = strchr(value, '=');
627 3870 : if (!equal_loc)
628 : {
629 0 : if (!DeleteVariable(pset.vars, value))
630 0 : exit(EXIT_FAILURE); /* error already printed */
631 : }
632 : else
633 : {
634 3870 : *equal_loc = '\0';
635 3870 : if (!SetVariable(pset.vars, value, equal_loc + 1))
636 0 : exit(EXIT_FAILURE); /* error already printed */
637 : }
638 :
639 3870 : free(value);
640 3870 : break;
641 : }
642 0 : case 'V':
643 0 : showVersion();
644 0 : exit(EXIT_SUCCESS);
645 26 : case 'w':
646 26 : pset.getPassword = TRI_NO;
647 26 : break;
648 0 : case 'W':
649 0 : pset.getPassword = TRI_YES;
650 0 : break;
651 0 : case 'x':
652 0 : pset.popt.topt.expanded = true;
653 0 : break;
654 6028 : case 'X':
655 6028 : options->no_psqlrc = true;
656 6028 : break;
657 0 : case 'z':
658 0 : pset.popt.topt.fieldSep.separator_zero = true;
659 0 : break;
660 0 : case '0':
661 0 : pset.popt.topt.recordSep.separator_zero = true;
662 0 : break;
663 0 : case '1':
664 0 : options->single_txn = true;
665 0 : break;
666 0 : case '?':
667 0 : if (optind <= argc &&
668 0 : strcmp(argv[optind - 1], "-?") == 0)
669 : {
670 : /* actual help option given */
671 0 : usage(NOPAGER);
672 0 : exit(EXIT_SUCCESS);
673 : }
674 : else
675 : {
676 : /* getopt error (unknown option or missing argument) */
677 0 : goto unknown_option;
678 : }
679 : break;
680 0 : case 1:
681 : {
682 0 : if (!optarg || strcmp(optarg, "options") == 0)
683 0 : usage(NOPAGER);
684 0 : else if (optarg && strcmp(optarg, "commands") == 0)
685 0 : slashUsage(NOPAGER);
686 0 : else if (optarg && strcmp(optarg, "variables") == 0)
687 0 : helpVariables(NOPAGER);
688 : else
689 0 : goto unknown_option;
690 :
691 0 : exit(EXIT_SUCCESS);
692 : }
693 : break;
694 0 : case 2:
695 0 : pset.popt.topt.format = PRINT_CSV;
696 0 : break;
697 : default:
698 0 : unknown_option:
699 0 : fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
700 : pset.progname);
701 0 : exit(EXIT_FAILURE);
702 : break;
703 : }
704 : }
705 :
706 : /*
707 : * if we still have arguments, use it as the database name and username
708 : */
709 6788 : while (argc - optind >= 1)
710 : {
711 760 : if (!options->dbname)
712 760 : options->dbname = argv[optind];
713 0 : else if (!options->username)
714 0 : options->username = argv[optind];
715 0 : else if (!pset.quiet)
716 0 : pg_log_warning("extra command-line argument \"%s\" ignored",
717 : argv[optind]);
718 :
719 760 : optind++;
720 : }
721 6028 : }
722 :
723 :
724 : /*
725 : * Append a new item to the end of the SimpleActionList.
726 : * Note that "val" is copied if it's not NULL.
727 : */
728 : static void
729 6070 : simple_action_list_append(SimpleActionList *list,
730 : enum _actions action, const char *val)
731 : {
732 : SimpleActionListCell *cell;
733 :
734 6070 : cell = (SimpleActionListCell *) pg_malloc(sizeof(SimpleActionListCell));
735 :
736 6070 : cell->next = NULL;
737 6070 : cell->action = action;
738 6070 : if (val)
739 4342 : cell->val = pg_strdup(val);
740 : else
741 1728 : cell->val = NULL;
742 :
743 6070 : if (list->tail)
744 44 : list->tail->next = cell;
745 : else
746 6026 : list->head = cell;
747 6070 : list->tail = cell;
748 6070 : }
749 :
750 :
751 : /*
752 : * Load .psqlrc file, if found.
753 : */
754 : static void
755 0 : process_psqlrc(char *argv0)
756 : {
757 : char home[MAXPGPATH];
758 : char rc_file[MAXPGPATH];
759 : char my_exec_path[MAXPGPATH];
760 : char etc_path[MAXPGPATH];
761 0 : char *envrc = getenv("PSQLRC");
762 :
763 0 : if (find_my_exec(argv0, my_exec_path) < 0)
764 : {
765 0 : pg_log_fatal("could not find own program executable");
766 0 : exit(EXIT_FAILURE);
767 : }
768 :
769 0 : get_etc_path(my_exec_path, etc_path);
770 :
771 0 : snprintf(rc_file, MAXPGPATH, "%s/%s", etc_path, SYSPSQLRC);
772 0 : process_psqlrc_file(rc_file);
773 :
774 0 : if (envrc != NULL && strlen(envrc) > 0)
775 0 : {
776 : /* might need to free() this */
777 0 : char *envrc_alloc = pstrdup(envrc);
778 :
779 0 : expand_tilde(&envrc_alloc);
780 0 : process_psqlrc_file(envrc_alloc);
781 : }
782 0 : else if (get_home_path(home))
783 : {
784 0 : snprintf(rc_file, MAXPGPATH, "%s/%s", home, PSQLRC);
785 0 : process_psqlrc_file(rc_file);
786 : }
787 0 : }
788 :
789 :
790 :
791 : static void
792 0 : process_psqlrc_file(char *filename)
793 : {
794 : char *psqlrc_minor,
795 : *psqlrc_major;
796 :
797 : #if defined(WIN32) && (!defined(__MINGW32__))
798 : #define R_OK 4
799 : #endif
800 :
801 0 : psqlrc_minor = psprintf("%s-%s", filename, PG_VERSION);
802 0 : psqlrc_major = psprintf("%s-%s", filename, PG_MAJORVERSION);
803 :
804 : /* check for minor version first, then major, then no version */
805 0 : if (access(psqlrc_minor, R_OK) == 0)
806 0 : (void) process_file(psqlrc_minor, false);
807 0 : else if (access(psqlrc_major, R_OK) == 0)
808 0 : (void) process_file(psqlrc_major, false);
809 0 : else if (access(filename, R_OK) == 0)
810 0 : (void) process_file(filename, false);
811 :
812 0 : free(psqlrc_minor);
813 0 : free(psqlrc_major);
814 0 : }
815 :
816 :
817 :
818 : /* showVersion
819 : *
820 : * This output format is intended to match GNU standards.
821 : */
822 : static void
823 0 : showVersion(void)
824 : {
825 0 : puts("psql (PostgreSQL) " PG_VERSION);
826 0 : }
827 :
828 :
829 :
830 : /*
831 : * Substitute hooks and assign hooks for psql variables.
832 : *
833 : * This isn't an amazingly good place for them, but neither is anywhere else.
834 : *
835 : * By policy, every special variable that controls any psql behavior should
836 : * have one or both hooks, even if they're just no-ops. This ensures that
837 : * the variable will remain present in variables.c's list even when unset,
838 : * which ensures that it's known to tab completion.
839 : */
840 :
841 : static char *
842 62300 : bool_substitute_hook(char *newval)
843 : {
844 62300 : if (newval == NULL)
845 : {
846 : /* "\unset FOO" becomes "\set FOO off" */
847 48228 : newval = pg_strdup("off");
848 : }
849 14072 : else if (newval[0] == '\0')
850 : {
851 : /* "\set FOO" becomes "\set FOO on" */
852 4 : pg_free(newval);
853 4 : newval = pg_strdup("on");
854 : }
855 62300 : return newval;
856 : }
857 :
858 : static bool
859 12060 : autocommit_hook(const char *newval)
860 : {
861 12060 : return ParseVariableBool(newval, "AUTOCOMMIT", &pset.autocommit);
862 : }
863 :
864 : static bool
865 8592 : on_error_stop_hook(const char *newval)
866 : {
867 8592 : return ParseVariableBool(newval, "ON_ERROR_STOP", &pset.on_error_stop);
868 : }
869 :
870 : static bool
871 10178 : quiet_hook(const char *newval)
872 : {
873 10178 : return ParseVariableBool(newval, "QUIET", &pset.quiet);
874 : }
875 :
876 : static bool
877 6028 : singleline_hook(const char *newval)
878 : {
879 6028 : return ParseVariableBool(newval, "SINGLELINE", &pset.singleline);
880 : }
881 :
882 : static bool
883 6028 : singlestep_hook(const char *newval)
884 : {
885 6028 : return ParseVariableBool(newval, "SINGLESTEP", &pset.singlestep);
886 : }
887 :
888 : static char *
889 6064 : fetch_count_substitute_hook(char *newval)
890 : {
891 6064 : if (newval == NULL)
892 6044 : newval = pg_strdup("0");
893 6064 : return newval;
894 : }
895 :
896 : static bool
897 6064 : fetch_count_hook(const char *newval)
898 : {
899 6064 : return ParseVariableNum(newval, "FETCH_COUNT", &pset.fetch_count);
900 : }
901 :
902 : static bool
903 6028 : histfile_hook(const char *newval)
904 : {
905 : /*
906 : * Someday we might try to validate the filename, but for now, this is
907 : * just a placeholder to ensure HISTFILE is known to tab completion.
908 : */
909 6028 : return true;
910 : }
911 :
912 : static char *
913 6028 : histsize_substitute_hook(char *newval)
914 : {
915 6028 : if (newval == NULL)
916 6028 : newval = pg_strdup("500");
917 6028 : return newval;
918 : }
919 :
920 : static bool
921 6028 : histsize_hook(const char *newval)
922 : {
923 6028 : return ParseVariableNum(newval, "HISTSIZE", &pset.histsize);
924 : }
925 :
926 : static char *
927 6028 : ignoreeof_substitute_hook(char *newval)
928 : {
929 : int dummy;
930 :
931 : /*
932 : * This tries to mimic the behavior of bash, to wit "If set, the value is
933 : * the number of consecutive EOF characters which must be typed as the
934 : * first characters on an input line before bash exits. If the variable
935 : * exists but does not have a numeric value, or has no value, the default
936 : * value is 10. If it does not exist, EOF signifies the end of input to
937 : * the shell." Unlike bash, however, we insist on the stored value
938 : * actually being a valid integer.
939 : */
940 6028 : if (newval == NULL)
941 6028 : newval = pg_strdup("0");
942 0 : else if (!ParseVariableNum(newval, NULL, &dummy))
943 0 : newval = pg_strdup("10");
944 6028 : return newval;
945 : }
946 :
947 : static bool
948 6028 : ignoreeof_hook(const char *newval)
949 : {
950 6028 : return ParseVariableNum(newval, "IGNOREEOF", &pset.ignoreeof);
951 : }
952 :
953 : static char *
954 7352 : echo_substitute_hook(char *newval)
955 : {
956 7352 : if (newval == NULL)
957 6028 : newval = pg_strdup("none");
958 7352 : return newval;
959 : }
960 :
961 : static bool
962 7352 : echo_hook(const char *newval)
963 : {
964 : Assert(newval != NULL); /* else substitute hook messed up */
965 7352 : if (pg_strcasecmp(newval, "queries") == 0)
966 2 : pset.echo = PSQL_ECHO_QUERIES;
967 7350 : else if (pg_strcasecmp(newval, "errors") == 0)
968 0 : pset.echo = PSQL_ECHO_ERRORS;
969 7350 : else if (pg_strcasecmp(newval, "all") == 0)
970 1314 : pset.echo = PSQL_ECHO_ALL;
971 6036 : else if (pg_strcasecmp(newval, "none") == 0)
972 6036 : pset.echo = PSQL_ECHO_NONE;
973 : else
974 : {
975 0 : PsqlVarEnumError("ECHO", newval, "none, errors, queries, all");
976 0 : return false;
977 : }
978 7352 : return true;
979 : }
980 :
981 : static bool
982 6028 : echo_hidden_hook(const char *newval)
983 : {
984 : Assert(newval != NULL); /* else substitute hook messed up */
985 6028 : if (pg_strcasecmp(newval, "noexec") == 0)
986 0 : pset.echo_hidden = PSQL_ECHO_HIDDEN_NOEXEC;
987 : else
988 : {
989 : bool on_off;
990 :
991 6028 : if (ParseVariableBool(newval, NULL, &on_off))
992 6028 : pset.echo_hidden = on_off ? PSQL_ECHO_HIDDEN_ON : PSQL_ECHO_HIDDEN_OFF;
993 : else
994 : {
995 0 : PsqlVarEnumError("ECHO_HIDDEN", newval, "on, off, noexec");
996 0 : return false;
997 : }
998 : }
999 6028 : return true;
1000 : }
1001 :
1002 : static bool
1003 6044 : on_error_rollback_hook(const char *newval)
1004 : {
1005 : Assert(newval != NULL); /* else substitute hook messed up */
1006 6044 : if (pg_strcasecmp(newval, "interactive") == 0)
1007 0 : pset.on_error_rollback = PSQL_ERROR_ROLLBACK_INTERACTIVE;
1008 : else
1009 : {
1010 : bool on_off;
1011 :
1012 6044 : if (ParseVariableBool(newval, NULL, &on_off))
1013 6040 : pset.on_error_rollback = on_off ? PSQL_ERROR_ROLLBACK_ON : PSQL_ERROR_ROLLBACK_OFF;
1014 : else
1015 : {
1016 4 : PsqlVarEnumError("ON_ERROR_ROLLBACK", newval, "on, off, interactive");
1017 4 : return false;
1018 : }
1019 : }
1020 6040 : return true;
1021 : }
1022 :
1023 : static char *
1024 6028 : comp_keyword_case_substitute_hook(char *newval)
1025 : {
1026 6028 : if (newval == NULL)
1027 6028 : newval = pg_strdup("preserve-upper");
1028 6028 : return newval;
1029 : }
1030 :
1031 : static bool
1032 6028 : comp_keyword_case_hook(const char *newval)
1033 : {
1034 : Assert(newval != NULL); /* else substitute hook messed up */
1035 6028 : if (pg_strcasecmp(newval, "preserve-upper") == 0)
1036 6028 : pset.comp_case = PSQL_COMP_CASE_PRESERVE_UPPER;
1037 0 : else if (pg_strcasecmp(newval, "preserve-lower") == 0)
1038 0 : pset.comp_case = PSQL_COMP_CASE_PRESERVE_LOWER;
1039 0 : else if (pg_strcasecmp(newval, "upper") == 0)
1040 0 : pset.comp_case = PSQL_COMP_CASE_UPPER;
1041 0 : else if (pg_strcasecmp(newval, "lower") == 0)
1042 0 : pset.comp_case = PSQL_COMP_CASE_LOWER;
1043 : else
1044 : {
1045 0 : PsqlVarEnumError("COMP_KEYWORD_CASE", newval,
1046 : "lower, upper, preserve-lower, preserve-upper");
1047 0 : return false;
1048 : }
1049 6028 : return true;
1050 : }
1051 :
1052 : static char *
1053 6028 : histcontrol_substitute_hook(char *newval)
1054 : {
1055 6028 : if (newval == NULL)
1056 6028 : newval = pg_strdup("none");
1057 6028 : return newval;
1058 : }
1059 :
1060 : static bool
1061 6028 : histcontrol_hook(const char *newval)
1062 : {
1063 : Assert(newval != NULL); /* else substitute hook messed up */
1064 6028 : if (pg_strcasecmp(newval, "ignorespace") == 0)
1065 0 : pset.histcontrol = hctl_ignorespace;
1066 6028 : else if (pg_strcasecmp(newval, "ignoredups") == 0)
1067 0 : pset.histcontrol = hctl_ignoredups;
1068 6028 : else if (pg_strcasecmp(newval, "ignoreboth") == 0)
1069 0 : pset.histcontrol = hctl_ignoreboth;
1070 6028 : else if (pg_strcasecmp(newval, "none") == 0)
1071 6028 : pset.histcontrol = hctl_none;
1072 : else
1073 : {
1074 0 : PsqlVarEnumError("HISTCONTROL", newval,
1075 : "none, ignorespace, ignoredups, ignoreboth");
1076 0 : return false;
1077 : }
1078 6028 : return true;
1079 : }
1080 :
1081 : static bool
1082 12056 : prompt1_hook(const char *newval)
1083 : {
1084 12056 : pset.prompt1 = newval ? newval : "";
1085 12056 : return true;
1086 : }
1087 :
1088 : static bool
1089 12056 : prompt2_hook(const char *newval)
1090 : {
1091 12056 : pset.prompt2 = newval ? newval : "";
1092 12056 : return true;
1093 : }
1094 :
1095 : static bool
1096 12056 : prompt3_hook(const char *newval)
1097 : {
1098 12056 : pset.prompt3 = newval ? newval : "";
1099 12056 : return true;
1100 : }
1101 :
1102 : static char *
1103 6092 : verbosity_substitute_hook(char *newval)
1104 : {
1105 6092 : if (newval == NULL)
1106 6028 : newval = pg_strdup("default");
1107 6092 : return newval;
1108 : }
1109 :
1110 : static bool
1111 6092 : verbosity_hook(const char *newval)
1112 : {
1113 : Assert(newval != NULL); /* else substitute hook messed up */
1114 6092 : if (pg_strcasecmp(newval, "default") == 0)
1115 6050 : pset.verbosity = PQERRORS_DEFAULT;
1116 42 : else if (pg_strcasecmp(newval, "verbose") == 0)
1117 0 : pset.verbosity = PQERRORS_VERBOSE;
1118 42 : else if (pg_strcasecmp(newval, "terse") == 0)
1119 30 : pset.verbosity = PQERRORS_TERSE;
1120 12 : else if (pg_strcasecmp(newval, "sqlstate") == 0)
1121 12 : pset.verbosity = PQERRORS_SQLSTATE;
1122 : else
1123 : {
1124 0 : PsqlVarEnumError("VERBOSITY", newval, "default, verbose, terse, sqlstate");
1125 0 : return false;
1126 : }
1127 :
1128 6092 : if (pset.db)
1129 64 : PQsetErrorVerbosity(pset.db, pset.verbosity);
1130 6092 : return true;
1131 : }
1132 :
1133 : static char *
1134 6066 : show_context_substitute_hook(char *newval)
1135 : {
1136 6066 : if (newval == NULL)
1137 6030 : newval = pg_strdup("errors");
1138 6066 : return newval;
1139 : }
1140 :
1141 : static bool
1142 6066 : show_context_hook(const char *newval)
1143 : {
1144 : Assert(newval != NULL); /* else substitute hook messed up */
1145 6066 : if (pg_strcasecmp(newval, "never") == 0)
1146 16 : pset.show_context = PQSHOW_CONTEXT_NEVER;
1147 6050 : else if (pg_strcasecmp(newval, "errors") == 0)
1148 6042 : pset.show_context = PQSHOW_CONTEXT_ERRORS;
1149 8 : else if (pg_strcasecmp(newval, "always") == 0)
1150 8 : pset.show_context = PQSHOW_CONTEXT_ALWAYS;
1151 : else
1152 : {
1153 0 : PsqlVarEnumError("SHOW_CONTEXT", newval, "never, errors, always");
1154 0 : return false;
1155 : }
1156 :
1157 6066 : if (pset.db)
1158 38 : PQsetErrorContextVisibility(pset.db, pset.show_context);
1159 6066 : return true;
1160 : }
1161 :
1162 : static bool
1163 7342 : hide_tableam_hook(const char *newval)
1164 : {
1165 7342 : return ParseVariableBool(newval, "HIDE_TABLEAM", &pset.hide_tableam);
1166 : }
1167 :
1168 : static void
1169 6028 : EstablishVariableSpace(void)
1170 : {
1171 6028 : pset.vars = CreateVariableSpace();
1172 :
1173 6028 : SetVariableHooks(pset.vars, "AUTOCOMMIT",
1174 : bool_substitute_hook,
1175 : autocommit_hook);
1176 6028 : SetVariableHooks(pset.vars, "ON_ERROR_STOP",
1177 : bool_substitute_hook,
1178 : on_error_stop_hook);
1179 6028 : SetVariableHooks(pset.vars, "QUIET",
1180 : bool_substitute_hook,
1181 : quiet_hook);
1182 6028 : SetVariableHooks(pset.vars, "SINGLELINE",
1183 : bool_substitute_hook,
1184 : singleline_hook);
1185 6028 : SetVariableHooks(pset.vars, "SINGLESTEP",
1186 : bool_substitute_hook,
1187 : singlestep_hook);
1188 6028 : SetVariableHooks(pset.vars, "FETCH_COUNT",
1189 : fetch_count_substitute_hook,
1190 : fetch_count_hook);
1191 6028 : SetVariableHooks(pset.vars, "HISTFILE",
1192 : NULL,
1193 : histfile_hook);
1194 6028 : SetVariableHooks(pset.vars, "HISTSIZE",
1195 : histsize_substitute_hook,
1196 : histsize_hook);
1197 6028 : SetVariableHooks(pset.vars, "IGNOREEOF",
1198 : ignoreeof_substitute_hook,
1199 : ignoreeof_hook);
1200 6028 : SetVariableHooks(pset.vars, "ECHO",
1201 : echo_substitute_hook,
1202 : echo_hook);
1203 6028 : SetVariableHooks(pset.vars, "ECHO_HIDDEN",
1204 : bool_substitute_hook,
1205 : echo_hidden_hook);
1206 6028 : SetVariableHooks(pset.vars, "ON_ERROR_ROLLBACK",
1207 : bool_substitute_hook,
1208 : on_error_rollback_hook);
1209 6028 : SetVariableHooks(pset.vars, "COMP_KEYWORD_CASE",
1210 : comp_keyword_case_substitute_hook,
1211 : comp_keyword_case_hook);
1212 6028 : SetVariableHooks(pset.vars, "HISTCONTROL",
1213 : histcontrol_substitute_hook,
1214 : histcontrol_hook);
1215 6028 : SetVariableHooks(pset.vars, "PROMPT1",
1216 : NULL,
1217 : prompt1_hook);
1218 6028 : SetVariableHooks(pset.vars, "PROMPT2",
1219 : NULL,
1220 : prompt2_hook);
1221 6028 : SetVariableHooks(pset.vars, "PROMPT3",
1222 : NULL,
1223 : prompt3_hook);
1224 6028 : SetVariableHooks(pset.vars, "VERBOSITY",
1225 : verbosity_substitute_hook,
1226 : verbosity_hook);
1227 6028 : SetVariableHooks(pset.vars, "SHOW_CONTEXT",
1228 : show_context_substitute_hook,
1229 : show_context_hook);
1230 6028 : SetVariableHooks(pset.vars, "HIDE_TABLEAM",
1231 : bool_substitute_hook,
1232 : hide_tableam_hook);
1233 6028 : }
|
