initdb.c

Bug Summary

File:	bin/initdb/initdb.c
Warning:	line 1100, column 14 Potential memory leak
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name initdb.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/local/lib/clang/12.0.0 -D FRONTEND -I ../../../src/interfaces/libpq -I ../../../src/timezone -I ../../../src/include -D _GNU_SOURCE -internal-isystem /usr/local/include -internal-isystem /usr/local/lib/clang/12.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-compound-token-split-by-macro -fdebug-compilation-dir /home/liang/Desktop/postgresSQL/postgres/src/bin/initdb -ferror-limit 19 -fwrapv -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-checker unix.Malloc -analyzer-disable-checker cplusplus.InnerPointer -analyzer-disable-checker cplusplus.Move -analyzer-disable-checker cplusplus.NewDelete -analyzer-disable-checker cplusplus.NewDeleteLeaks -analyzer-disable-checker cplusplus.PlacementNew -analyzer-disable-checker cplusplus.PureVirtualCall -analyzer-disable-checker deadcode.DeadStores -analyzer-disable-checker nullability.NullPassedToNonnull -analyzer-disable-checker nullability.NullReturnedFromNonnull -analyzer-disable-checker security.insecureAPI.UncheckedReturn -analyzer-disable-checker security.insecureAPI.getpw -analyzer-disable-checker security.insecureAPI.gets -analyzer-disable-checker security.insecureAPI.mkstemp -analyzer-disable-checker security.insecureAPI.mktemp -analyzer-disable-checker security.insecureAPI.vfork -analyzer-disable-checker unix.API -analyzer-disable-checker unix.MallocSizeof -analyzer-disable-checker unix.MismatchedDeallocator -analyzer-disable-checker unix.Vfork -analyzer-disable-checker unix.cstring.BadSizeArg -analyzer-disable-checker unix.cstring.NullArg -analyzer-output=html -analyzer-config silence-checkers=core.CallAndMessage;core.DivideZero;core.NonNullParamChecker;core.NullDereference;core.UndefinedBinaryOperatorResult;core.VLASize;core.uninitialized.ArraySubscript;core.uninitialized.Assign;core.uninitialized.Branch;core.uninitialized.CapturedBlockVariable;core.uninitialized.UndefReturn -faddrsig -o /home/liang/Desktop/postgresSQL/AnalyzeResult/2022-02-13-214037-106503-1 -x c initdb.c
1/*-------------------------------------------------------------------------
*
* initdb --- initialize a PostgreSQL installation
*
* initdb creates (initializes) a PostgreSQL database cluster (site,
* instance, installation, whatever).  A database cluster is a
* collection of PostgreSQL databases all managed by the same server.
*
* To create the database cluster, we create the directory that contains
* all its data, create the files that hold the global tables, create
* a few other control files for it, and create three databases: the
* template databases "template0" and "template1", and a default user
* database "postgres".
*
* The template databases are ordinary PostgreSQL databases.  template0
* is never supposed to change after initdb, whereas template1 can be
* changed to add site-local standard data.  Either one can be copied
* to produce a new database.
*
* For largely-historical reasons, the template1 database is the one built
* by the basic bootstrap process.  After it is complete, template0 and
* the default database, postgres, are made just by copying template1.
*
* To create template1, we run the postgres (backend) program in bootstrap
* mode and feed it data from the postgres.bki library file.  After this
* initial bootstrap phase, some additional stuff is created by normal
* SQL commands fed to a standalone backend.  Some of those commands are
* just embedded into this program (yeah, it's ugly), but larger chunks
* are taken from script files.
*
*
* Note:
*	 The program has some memory leakage - it isn't worth cleaning it up.
*
* This is a C implementation of the previous shell script for setting up a
* PostgreSQL cluster location, and should be highly compatible with it.
* author of C translation: Andrew Dunstan	   mailto:andrew@dunslane.net
*
* This code is released under the terms of the PostgreSQL License.
*
* Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/bin/initdb/initdb.c
*
*-------------------------------------------------------------------------
*/

49#include "postgres_fe.h"

51#include <dirent.h>
52#include <fcntl.h>
53#include <sys/stat.h>
54#include <unistd.h>
55#include <signal.h>
56#include <time.h>

58#ifdef HAVE_SHM_OPEN1
59#include "sys/mman.h"
60#endif

62#include "access/transam.h"
63#include "access/xlog_internal.h"
64#include "catalog/pg_authid_d.h"
65#include "catalog/pg_class_d.h" /* pgrminclude ignore */
66#include "catalog/pg_collation_d.h"
67#include "common/file_perm.h"
68#include "common/file_utils.h"
69#include "common/logging.h"
70#include "common/pg_prng.h"
71#include "common/restricted_token.h"
72#include "common/string.h"
73#include "common/username.h"
74#include "fe_utils/string_utils.h"
75#include "getaddrinfo.h"
76#include "getopt_long.h"
77#include "mb/pg_wchar.h"
78#include "miscadmin.h"


81/* Ideally this would be in a .h file, but it hardly seems worth the trouble */
82extern const char *select_default_timezone(const char *share_path);

84static const char *const auth_methods_host[] = {
"trust", "reject", "scram-sha-256", "md5", "password", "ident", "radius",
86#ifdef ENABLE_GSS
"gss",
88#endif
89#ifdef ENABLE_SSPI
"sspi",
91#endif
92#ifdef USE_PAM
"pam", "pam ",
94#endif
95#ifdef USE_BSD_AUTH
"bsd",
97#endif
98#ifdef USE_LDAP
"ldap",
100#endif
101#ifdef USE_SSL
"cert",
103#endif
NULL((void*)0)
105};
106static const char *const auth_methods_local[] = {
"trust", "reject", "scram-sha-256", "md5", "password", "peer", "radius",
108#ifdef USE_PAM
"pam", "pam ",
110#endif
111#ifdef USE_BSD_AUTH
"bsd",
113#endif
114#ifdef USE_LDAP
"ldap",
116#endif
NULL((void*)0)
118};

120/*
* these values are passed in by makefile defines
*/
123static char *share_path = NULL((void*)0);

125/* values to be obtained from arguments */
126static char *pg_data = NULL((void*)0);
127static char *encoding = NULL((void*)0);
128static char *locale = NULL((void*)0);
129static char *lc_collate = NULL((void*)0);
130static char *lc_ctype = NULL((void*)0);
131static char *lc_monetary = NULL((void*)0);
132static char *lc_numeric = NULL((void*)0);
133static char *lc_time = NULL((void*)0);
134static char *lc_messages = NULL((void*)0);
135static const char *default_text_search_config = NULL((void*)0);
136static char *username = NULL((void*)0);
137static bool_Bool pwprompt = false0;
138static char *pwfilename = NULL((void*)0);
139static char *superuser_password = NULL((void*)0);
140static const char *authmethodhost = NULL((void*)0);
141static const char *authmethodlocal = NULL((void*)0);
142static bool_Bool debug = false0;
143static bool_Bool noclean = false0;
144static bool_Bool noinstructions = false0;
145static bool_Bool do_sync = true1;
146static bool_Bool sync_only = false0;
147static bool_Bool show_setting = false0;
148static bool_Bool data_checksums = false0;
149static char *xlog_dir = NULL((void*)0);
150static char *str_wal_segment_size_mb = NULL((void*)0);
151static int	wal_segment_size_mb;


154/* internal vars */
155static const char *progname;
156static int	encodingid;
157static char *bki_file;
158static char *hba_file;
159static char *ident_file;
160static char *conf_file;
161static char *dictionary_file;
162static char *info_schema_file;
163static char *features_file;
164static char *system_constraints_file;
165static char *system_functions_file;
166static char *system_views_file;
167static bool_Bool success = false0;
168static bool_Bool made_new_pgdata = false0;
169static bool_Bool found_existing_pgdata = false0;
170static bool_Bool made_new_xlogdir = false0;
171static bool_Bool found_existing_xlogdir = false0;
172static char infoversion[100];
173static bool_Bool caught_signal = false0;
174static bool_Bool output_failed = false0;
175static int	output_errno = 0;
176static char *pgdata_native;

178/* defaults */
179static int	n_connections = 10;
180static int	n_buffers = 50;
181static const char *dynamic_shared_memory_type = NULL((void*)0);
182static const char *default_timezone = NULL((void*)0);

184/*
* Warning messages for authentication methods
*/
187#define AUTHTRUST_WARNING"# CAUTION: Configuring the system for local \"trust\" authentication\n"
 "# allows any local user to connect as any PostgreSQL user, including\n"
 "# the database superuser.  If you do not trust all your local users,\n"
 "# use another authentication method.\n" \
188"# CAUTION: Configuring the system for local \"trust\" authentication\n" \
189"# allows any local user to connect as any PostgreSQL user, including\n" \
190"# the database superuser.  If you do not trust all your local users,\n" \
191"# use another authentication method.\n"
192static bool_Bool authwarning = false0;

194/*
* Centralized knowledge of switches to pass to backend
*
* Note: we run the backend with -F (fsync disabled) and then do a single
* pass of fsync'ing at the end.  This is faster than fsync'ing each step.
*
* Note: in the shell-script version, we also passed PGDATA as a -D switch,
* but here it is more convenient to pass it as an environment variable
* (no quoting to worry about).
*/
204static const char *boot_options = "-F -c log_checkpoints=false";
205static const char *backend_options = "--single -F -O -j -c search_path=pg_catalog -c exit_on_error=true -c log_checkpoints=false";

207/* Additional switches to pass to backend (either boot or standalone) */
208static char *extra_options = "";

210static const char *const subdirs[] = {
"global",
"pg_wal/archive_status",
"pg_commit_ts",
"pg_dynshmem",
"pg_notify",
"pg_serial",
"pg_snapshots",
"pg_subtrans",
"pg_twophase",
"pg_multixact",
"pg_multixact/members",
"pg_multixact/offsets",
"base",
"base/1",
"pg_replslot",
"pg_tblspc",
"pg_stat",
"pg_stat_tmp",
"pg_xact",
"pg_logical",
"pg_logical/snapshots",
"pg_logical/mappings"
233};


236/* path to 'initdb' binary directory */
237static char bin_path[MAXPGPATH1024];
238static char backend_exec[MAXPGPATH1024];

240static char **replace_token(char **lines,
					const char *token, const char *replacement);

243#ifndef HAVE_UNIX_SOCKETS1
244static char **filter_lines_with_token(char **lines, const char *token);
245#endif
246static char **readfile(const char *path);
247static void writefile(char *path, char **lines);
248static FILE *popen_check(const char *command, const char *mode);
249static char *get_id(void);
250static int	get_encoding_id(const char *encoding_name);
251static void set_input(char **dest, const char *filename);
252static void check_input(char *path);
253static void write_version_file(const char *extrapath);
254static void set_null_conf(void);
255static void test_config_settings(void);
256static void setup_config(void);
257static void bootstrap_template1(void);
258static void setup_auth(FILE *cmdfd);
259static void get_su_pwd(void);
260static void setup_depend(FILE *cmdfd);
261static void setup_run_file(FILE *cmdfd, const char *filename);
262static void setup_description(FILE *cmdfd);
263static void setup_collation(FILE *cmdfd);
264static void setup_privileges(FILE *cmdfd);
265static void set_info_version(void);
266static void setup_schema(FILE *cmdfd);
267static void load_plpgsql(FILE *cmdfd);
268static void vacuum_db(FILE *cmdfd);
269static void make_template0(FILE *cmdfd);
270static void make_postgres(FILE *cmdfd);
271static void trapsig(int signum);
272static void check_ok(void);
273static char *escape_quotes(const char *src);
274static char *escape_quotes_bki(const char *src);
275static int	locale_date_order(const char *locale);
276static void check_locale_name(int category, const char *locale,
					  char **canonname);
278static bool_Bool check_locale_encoding(const char *locale, int encoding);
279static void setlocales(void);
280static void usage(const char *progname);
281void		setup_pgdata(void);
282void		setup_bin_paths(const char *argv0);
283void		setup_data_file_paths(void);
284void		setup_locale_encoding(void);
285void		setup_signals(void);
286void		setup_text_search(void);
287void		create_data_directory(void);
288void		create_xlog_or_symlink(void);
289void		warn_on_mount_point(int error);
290void		initialize_data_directory(void);

292/*
* macros for running pipes to postgres
*/
295#define PG_CMD_DECLchar cmd[1024]; FILE *cmdfd		char cmd[MAXPGPATH1024]; FILE *cmdfd

297#define PG_CMD_OPENdo { cmdfd = popen_check(cmd, "w"); if (cmdfd == ((void*)0)) exit
(1); } while (0) \
298do { \
cmdfd = popen_check(cmd, "w"); \
if (cmdfd == NULL((void*)0)) \
exit(1); /* message already printed by popen_check */ \
302} while (0)

304#define PG_CMD_CLOSEdo { if (pclose_check(cmdfd)) exit(1); } while (0) \
305do { \
if (pclose_check(cmdfd)) \
exit(1); /* message already printed by pclose_check */ \
308} while (0)

310#define PG_CMD_PUTS(line)do { if (fputs(line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0) \
311do { \
if (fputs(line, cmdfd) < 0 || fflush(cmdfd) < 0) \
output_failed = true1, output_errno = errno(*__errno_location ()); \
314} while (0)

316#define PG_CMD_PRINTF(fmt, ...)do { if (pg_fprintf(cmdfd, fmt, ...) < 0 || fflush(cmdfd) <
 0) output_failed = 1, output_errno = (*__errno_location ());
 } while (0) \
317do { \
if (fprintfpg_fprintf(cmdfd, fmt, __VA_ARGS__) < 0 || fflush(cmdfd) < 0) \
output_failed = true1, output_errno = errno(*__errno_location ()); \
320} while (0)

322/*
* Escape single quotes and backslashes, suitably for insertions into
* configuration files or SQL E'' strings.
*/
326static char *
327escape_quotes(const char *src)
328{
char	   *result = escape_single_quotes_ascii(src);

if (!result)
{
pg_log_error("out of memory")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "out of memory"); } while
(0);
exit(1);
}
return result;
337}

339/*
* Escape a field value to be inserted into the BKI data.
* Run the value through escape_quotes (which will be inverted
* by the backend's DeescapeQuotedString() function), then wrap
* the value in single quotes, even if that isn't strictly necessary.
*/
345static char *
346escape_quotes_bki(const char *src)
347{
char	   *result;
char	   *data = escape_quotes(src);
char	   *resultp;
char	   *datap;

result = (char *) pg_malloc(strlen(data) + 3);
resultp = result;
*resultp++ = '\'';
for (datap = data; *datap; datap++)
*resultp++ = *datap;
*resultp++ = '\'';
*resultp = '\0';

free(data);
return result;
363}

365/*
* make a copy of the array of lines, with token replaced by replacement
* the first time it occurs on each line.
*
* This does most of what sed was used for in the shell script, but
* doesn't need any regexp stuff.
*/
372static char **
373replace_token(char **lines, const char *token, const char *replacement)
374{
int			numlines = 1;
int			i;
char	  **result;
int			toklen,
		replen,
		diff;

for (i = 0; lines[i]; i++)
numlines++;

result = (char **) pg_malloc(numlines * sizeof(char *));

toklen = strlen(token);
replen = strlen(replacement);
diff = replen - toklen;

for (i = 0; i < numlines; i++)
{
char	   *where;
char	   *newline;
int			pre;

/* just copy pointer if NULL or no change needed */
if (lines[i] == NULL((void*)0) || (where = strstr(lines[i], token)) == NULL((void*)0))
{
	result[i] = lines[i];
	continue;
}

/* if we get here a change is needed - set up new line */

newline = (char *) pg_malloc(strlen(lines[i]) + diff + 1);

pre = where - lines[i];

memcpy(newline, lines[i], pre);

memcpy(newline + pre, replacement, replen);

strcpy(newline + pre + replen, lines[i] + pre + toklen);

result[i] = newline;
}

return result;
420}

422/*
* make a copy of lines without any that contain the token
*
* a sort of poor man's grep -v
*/
427#ifndef HAVE_UNIX_SOCKETS1
428static char **
429filter_lines_with_token(char **lines, const char *token)
430{
int			numlines = 1;
int			i,
		src,
		dst;
char	  **result;

for (i = 0; lines[i]; i++)
numlines++;

result = (char **) pg_malloc(numlines * sizeof(char *));

for (src = 0, dst = 0; src < numlines; src++)
{
if (lines[src] == NULL((void*)0) || strstr(lines[src], token) == NULL((void*)0))
	result[dst++] = lines[src];
}

return result;
449}
450#endif

452/*
* get the lines from a text file
*/
455static char **
456readfile(const char *path)
457{
char	  **result;
FILE	   *infile;
StringInfoData line;
int			maxlines;
int			n;

if ((infile = fopen(path, "r")) == NULL((void*)0))
{
pg_log_error("could not open file \"%s\" for reading: %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for reading: %m"
, path); } while(0);
exit(1);
}

initStringInfo(&line);

maxlines = 1024;
result = (char **) pg_malloc(maxlines * sizeof(char *));

n = 0;
while (pg_get_line_buf(infile, &line))
{
/* make sure there will be room for a trailing NULL pointer */
if (n >= maxlines - 1)
{
	maxlines *= 2;
	result = (char **) pg_realloc(result, maxlines * sizeof(char *));
}

result[n++] = pg_strdup(line.data);
}
result[n] = NULL((void*)0);

pfree(line.data);

fclose(infile);

return result;
494}

496/*
* write an array of lines to a file
*
* This is only used to write text files.  Use fopen "w" not PG_BINARY_W
* so that the resulting configuration files are nicely editable on Windows.
*/
502static void
503writefile(char *path, char **lines)
504{
FILE	   *out_file;
char	  **line;

if ((out_file = fopen(path, "w")) == NULL((void*)0))
{
pg_log_error("could not open file \"%s\" for writing: %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for writing: %m"
, path); } while(0);
exit(1);
}
for (line = lines; *line != NULL((void*)0); line++)
{
if (fputs(*line, out_file) < 0)
{
	pg_log_error("could not write file \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not write file \"%s\": %m"
, path); } while(0);
	exit(1);
}
free(*line);
}
if (fclose(out_file))
{
pg_log_error("could not write file \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not write file \"%s\": %m"
, path); } while(0);
exit(1);
}
527}

529/*
* Open a subcommand with suitable error messaging
*/
532static FILE *
533popen_check(const char *command, const char *mode)
534{
FILE	   *cmdfd;

fflush(stdoutstdout);
fflush(stderrstderr);
errno(*__errno_location ()) = 0;
cmdfd = popen(command, mode);
if (cmdfd == NULL((void*)0))
pg_log_error("could not execute command \"%s\": %m", command)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not execute command \"%s\": %m"
, command); } while(0);
return cmdfd;
544}

546/*
* clean up any files we created on failure
* if we created the data directory remove it too
*/
550static void
551cleanup_directories_atexit(void)
552{
if (success)
return;

if (!noclean)
{
if (made_new_pgdata)
{
	pg_log_info("removing data directory \"%s\"", pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "removing data directory \"%s\""
, pg_data); } while(0);
	if (!rmtree(pg_data, true1))
		pg_log_error("failed to remove data directory")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "failed to remove data directory"
); } while(0);
}
else if (found_existing_pgdata)
{
	pg_log_info("removing contents of data directory \"%s\"",do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "removing contents of data directory \"%s\""
, pg_data); } while(0)
				pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "removing contents of data directory \"%s\""
, pg_data); } while(0);
	if (!rmtree(pg_data, false0))
		pg_log_error("failed to remove contents of data directory")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "failed to remove contents of data directory"
); } while(0);
}

if (made_new_xlogdir)
{
	pg_log_info("removing WAL directory \"%s\"", xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "removing WAL directory \"%s\""
, xlog_dir); } while(0);
	if (!rmtree(xlog_dir, true1))
		pg_log_error("failed to remove WAL directory")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "failed to remove WAL directory"
); } while(0);
}
else if (found_existing_xlogdir)
{
	pg_log_info("removing contents of WAL directory \"%s\"", xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "removing contents of WAL directory \"%s\""
, xlog_dir); } while(0);
	if (!rmtree(xlog_dir, false0))
		pg_log_error("failed to remove contents of WAL directory")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "failed to remove contents of WAL directory"
); } while(0);
}
/* otherwise died during startup, do nothing! */
}
else
{
if (made_new_pgdata || found_existing_pgdata)
	pg_log_info("data directory \"%s\" not removed at user's request",do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "data directory \"%s\" not removed at user's request"
, pg_data); } while(0)
				pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "data directory \"%s\" not removed at user's request"
, pg_data); } while(0);

if (made_new_xlogdir || found_existing_xlogdir)
	pg_log_info("WAL directory \"%s\" not removed at user's request",do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "WAL directory \"%s\" not removed at user's request"
, xlog_dir); } while(0)
				xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "WAL directory \"%s\" not removed at user's request"
, xlog_dir); } while(0);
}
596}

598/*
* find the current user
*
* on unix make sure it isn't root
*/
603static char *
604get_id(void)
605{
const char *username;

608#ifndef WIN32
if (geteuid() == 0)			/* 0 is root's uid */
{
pg_log_error("cannot be run as root")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "cannot be run as root"
); } while(0);
fprintfpg_fprintf(stderrstderr,
		_("Please log in (using, e.g., \"su\") as the (unprivileged) user that will\n"("Please log in (using, e.g., \"su\") as the (unprivileged) user that will\n"
 "own the server process.\n")
		  "own the server process.\n")("Please log in (using, e.g., \"su\") as the (unprivileged) user that will\n"
 "own the server process.\n"));
exit(1);
}
617#endif

username = get_user_name_or_exit(progname);

return pg_strdup(username);
622}

624static char *
625encodingid_to_string(int enc)
626{
char		result[20];

sprintfpg_sprintf(result, "%d", enc);
return pg_strdup(result);
631}

633/*
* get the encoding id for a given encoding name
*/
636static int
637get_encoding_id(const char *encoding_name)
638{
int			enc;

if (encoding_name && *encoding_name)
{
if ((enc = pg_valid_server_encoding(encoding_name)) >= 0)
	return enc;
}
pg_log_error("\"%s\" is not a valid server encoding name",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "\"%s\" is not a valid server encoding name"
, encoding_name ? encoding_name : "(null)"); } while(0)
		 encoding_name ? encoding_name : "(null)")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "\"%s\" is not a valid server encoding name"
, encoding_name ? encoding_name : "(null)"); } while(0);
exit(1);
649}

651/*
* Support for determining the best default text search configuration.
* We key this off the first part of LC_CTYPE (ie, the language name).
*/
655struct tsearch_config_match
656{
const char *tsconfname;
const char *langname;
659};

661static const struct tsearch_config_match tsearch_config_languages[] =
662{
{"arabic", "ar"},
{"arabic", "Arabic"},
{"armenian", "hy"},
{"armenian", "Armenian"},
{"basque", "eu"},
{"basque", "Basque"},
{"catalan", "ca"},
{"catalan", "Catalan"},
{"danish", "da"},
{"danish", "Danish"},
{"dutch", "nl"},
{"dutch", "Dutch"},
{"english", "C"},
{"english", "POSIX"},
{"english", "en"},
{"english", "English"},
{"finnish", "fi"},
{"finnish", "Finnish"},
{"french", "fr"},
{"french", "French"},
{"german", "de"},
{"german", "German"},
{"greek", "el"},
{"greek", "Greek"},
{"hindi", "hi"},
{"hindi", "Hindi"},
{"hungarian", "hu"},
{"hungarian", "Hungarian"},
{"indonesian", "id"},
{"indonesian", "Indonesian"},
{"irish", "ga"},
{"irish", "Irish"},
{"italian", "it"},
{"italian", "Italian"},
{"lithuanian", "lt"},
{"lithuanian", "Lithuanian"},
{"nepali", "ne"},
{"nepali", "Nepali"},
{"norwegian", "no"},
{"norwegian", "Norwegian"},
{"portuguese", "pt"},
{"portuguese", "Portuguese"},
{"romanian", "ro"},
{"russian", "ru"},
{"russian", "Russian"},
{"serbian", "sr"},
{"serbian", "Serbian"},
{"spanish", "es"},
{"spanish", "Spanish"},
{"swedish", "sv"},
{"swedish", "Swedish"},
{"tamil", "ta"},
{"tamil", "Tamil"},
{"turkish", "tr"},
{"turkish", "Turkish"},
{"yiddish", "yi"},
{"yiddish", "Yiddish"},
{NULL((void*)0), NULL((void*)0)}				/* end marker */
721};

723/*
* Look for a text search configuration matching lc_ctype, and return its
* name; return NULL if no match.
*/
727static const char *
728find_matching_ts_config(const char *lc_type)
729{
int			i;
char	   *langname,
	   *ptr;

/*
* Convert lc_ctype to a language name by stripping everything after an
* underscore (usual case) or a hyphen (Windows "locale name"; see
* comments at IsoLocaleName()).
*
* XXX Should ' ' be a stop character?	This would select "norwegian" for
* the Windows locale "Norwegian (Nynorsk)_Norway.1252".  If we do so, we
* should also accept the "nn" and "nb" Unix locales.
*
* Just for paranoia, we also stop at '.' or '@'.
*/
if (lc_type == NULL((void*)0))
langname = pg_strdup("");
else
{
ptr = langname = pg_strdup(lc_type);
while (*ptr &&
	   *ptr != '_' && *ptr != '-' && *ptr != '.' && *ptr != '@')
	ptr++;
*ptr = '\0';
}

for (i = 0; tsearch_config_languages[i].tsconfname; i++)
{
if (pg_strcasecmp(tsearch_config_languages[i].langname, langname) == 0)
{
	free(langname);
	return tsearch_config_languages[i].tsconfname;
}
}

free(langname);
return NULL((void*)0);
767}


770/*
* set name of given input file variable under data directory
*/
773static void
774set_input(char **dest, const char *filename)
775{
*dest = psprintf("%s/%s", share_path, filename);
777}

779/*
* check that given input file exists
*/
782static void
783check_input(char *path)
784{
struct stat statbuf;

if (stat(path, &statbuf) != 0)
{
if (errno(*__errno_location ()) == ENOENT2)
{
	pg_log_error("file \"%s\" does not exist", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "file \"%s\" does not exist"
, path); } while(0);
	fprintfpg_fprintf(stderrstderr,
			_("This might mean you have a corrupted installation or identified\n"("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n")
			  "the wrong directory with the invocation option -L.\n")("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n"));
}
else
{
	pg_log_error("could not access file \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not access file \"%s\": %m"
, path); } while(0);
	fprintfpg_fprintf(stderrstderr,
			_("This might mean you have a corrupted installation or identified\n"("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n")
			  "the wrong directory with the invocation option -L.\n")("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n"));
}
exit(1);
}
if (!S_ISREG(statbuf.st_mode)((((statbuf.st_mode)) & 0170000) == (0100000)))
{
pg_log_error("file \"%s\" is not a regular file", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "file \"%s\" is not a regular file"
, path); } while(0);
fprintfpg_fprintf(stderrstderr,
		_("This might mean you have a corrupted installation or identified\n"("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n")
		  "the wrong directory with the invocation option -L.\n")("This might mean you have a corrupted installation or identified\n"
 "the wrong directory with the invocation option -L.\n"));
exit(1);
}
813}

815/*
* write out the PG_VERSION file in the data dir, or its subdirectory
* if extrapath is not NULL
*/
819static void
820write_version_file(const char *extrapath)
821{
FILE	   *version_file;
char	   *path;

if (extrapath == NULL((void*)0))
path = psprintf("%s/PG_VERSION", pg_data);
else
path = psprintf("%s/%s/PG_VERSION", pg_data, extrapath);

if ((version_file = fopen(path, PG_BINARY_W"w")) == NULL((void*)0))
{
pg_log_error("could not open file \"%s\" for writing: %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for writing: %m"
, path); } while(0);
exit(1);
}
if (fprintfpg_fprintf(version_file, "%s\n", PG_MAJORVERSION"15") < 0 ||
fclose(version_file))
{
pg_log_error("could not write file \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not write file \"%s\": %m"
, path); } while(0);
exit(1);
}
free(path);
842}

844/*
* set up an empty config file so we can check config settings by launching
* a test backend
*/
848static void
849set_null_conf(void)
850{
FILE	   *conf_file;
char	   *path;

path = psprintf("%s/postgresql.conf", pg_data);
conf_file = fopen(path, PG_BINARY_W"w");
if (conf_file == NULL((void*)0))
{
pg_log_error("could not open file \"%s\" for writing: %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for writing: %m"
, path); } while(0);
exit(1);
}
if (fclose(conf_file))
{
pg_log_error("could not write file \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not write file \"%s\": %m"
, path); } while(0);
exit(1);
}
free(path);
867}

869/*
* Determine which dynamic shared memory implementation should be used on
* this platform.  POSIX shared memory is preferable because the default
* allocation limits are much higher than the limits for System V on most
* systems that support both, but the fact that a platform has shm_open
* doesn't guarantee that that call will succeed when attempted.  So, we
* attempt to reproduce what the postmaster will do when allocating a POSIX
* segment in dsm_impl.c; if it doesn't work, we assume it won't work for
* the postmaster either, and configure the cluster for System V shared
* memory instead.
*/
880static const char *
881choose_dsm_implementation(void)
882{
883#ifdef HAVE_SHM_OPEN1
int			ntries = 10;
pg_prng_state prng_state;

/* Initialize prng; this function is its only user in this program. */
pg_prng_seed(&prng_state, (uint64) (getpid() ^ time(NULL((void*)0))));

while (ntries > 0)
{
uint32		handle;
char		name[64];
int			fd;

handle = pg_prng_uint32(&prng_state);
snprintfpg_snprintf(name, 64, "/PostgreSQL.%u", handle);
if ((fd = shm_open(name, O_CREAT0100 | O_RDWR02 | O_EXCL0200, 0600)) != -1)
{
	close(fd);
	shm_unlink(name);
	return "posix";
}
if (errno(*__errno_location ()) != EEXIST17)
	break;
--ntries;
}
908#endif

910#ifdef WIN32
return "windows";
912#else
return "sysv";
914#endif
915}

917/*
* Determine platform-specific config settings
*
* Use reasonable values if kernel will let us, else scale back.
*/
922static void
923test_config_settings(void)
924{
/*
* This macro defines the minimum shared_buffers we want for a given
* max_connections value. The arrays show the settings to try.
*/
929#define MIN_BUFS_FOR_CONNS(nconns)((nconns) * 10)	((nconns) * 10)

static const int trial_conns[] = {
100, 50, 40, 30, 20
};
static const int trial_bufs[] = {
16384, 8192, 4096, 3584, 3072, 2560, 2048, 1536,
1000, 900, 800, 700, 600, 500,
400, 300, 200, 100, 50
};

char		cmd[MAXPGPATH1024];
const int	connslen = sizeof(trial_conns) / sizeof(int);
const int	bufslen = sizeof(trial_bufs) / sizeof(int);
int			i,
		status,
		test_conns,
		test_buffs,
		ok_buffers = 0;

/*
* Need to determine working DSM implementation first so that subsequent
* tests don't fail because DSM setting doesn't work.
*/
printf(_("selecting dynamic shared memory implementation ... "))pg_printf(("selecting dynamic shared memory implementation ... "
));
fflush(stdoutstdout);
dynamic_shared_memory_type = choose_dsm_implementation();
printf("%s\n", dynamic_shared_memory_type)pg_printf("%s\n", dynamic_shared_memory_type);

/*
* Probe for max_connections before shared_buffers, since it is subject to
* more constraints than shared_buffers.
*/
printf(_("selecting default max_connections ... "))pg_printf(("selecting default max_connections ... "));
fflush(stdoutstdout);

for (i = 0; i < connslen; i++)
{
test_conns = trial_conns[i];
test_buffs = MIN_BUFS_FOR_CONNS(test_conns)((test_conns) * 10);

snprintfpg_snprintf(cmd, sizeof(cmd),
		 "\"%s\" --check %s %s "
		 "-c max_connections=%d "
		 "-c shared_buffers=%d "
		 "-c dynamic_shared_memory_type=%s "
		 "< \"%s\" > \"%s\" 2>&1",
		 backend_exec, boot_options, extra_options,
		 test_conns, test_buffs,
		 dynamic_shared_memory_type,
		 DEVNULL"/dev/null", DEVNULL"/dev/null");
status = system(cmd);
if (status == 0)
{
	ok_buffers = test_buffs;
	break;
}
}
if (i >= connslen)
i = connslen - 1;
n_connections = trial_conns[i];

printf("%d\n", n_connections)pg_printf("%d\n", n_connections);

printf(_("selecting default shared_buffers ... "))pg_printf(("selecting default shared_buffers ... "));
fflush(stdoutstdout);

for (i = 0; i < bufslen; i++)
{
/* Use same amount of memory, independent of BLCKSZ */
test_buffs = (trial_bufs[i] * 8192) / BLCKSZ8192;
if (test_buffs <= ok_buffers)
{
	test_buffs = ok_buffers;
	break;
}

snprintfpg_snprintf(cmd, sizeof(cmd),
		 "\"%s\" --check %s %s "
		 "-c max_connections=%d "
		 "-c shared_buffers=%d "
		 "-c dynamic_shared_memory_type=%s "
		 "< \"%s\" > \"%s\" 2>&1",
		 backend_exec, boot_options, extra_options,
		 n_connections, test_buffs,
		 dynamic_shared_memory_type,
		 DEVNULL"/dev/null", DEVNULL"/dev/null");
status = system(cmd);
if (status == 0)
	break;
}
n_buffers = test_buffs;

if ((n_buffers * (BLCKSZ8192 / 1024)) % 1024 == 0)
printf("%dMB\n", (n_buffers * (BLCKSZ / 1024)) / 1024)pg_printf("%dMB\n", (n_buffers * (8192 / 1024)) / 1024);
else
printf("%dkB\n", n_buffers * (BLCKSZ / 1024))pg_printf("%dkB\n", n_buffers * (8192 / 1024));

printf(_("selecting default time zone ... "))pg_printf(("selecting default time zone ... "));
fflush(stdoutstdout);
default_timezone = select_default_timezone(share_path);
printf("%s\n", default_timezone ? default_timezone : "GMT")pg_printf("%s\n", default_timezone ? default_timezone : "GMT"
);
1031}

1033/*
* Calculate the default wal_size with a "pretty" unit.
*/
1036static char *
1037pretty_wal_size(int segment_count)
1038{
int			sz = wal_segment_size_mb * segment_count;
char	   *result = pg_malloc(14);
4
←
Memory is allocated→

if ((sz % 1024) == 0)
5
←
Assuming the condition is false→
6
←
Taking false branch→
snprintfpg_snprintf(result, 14, "%dGB", sz / 1024);
else
snprintfpg_snprintf(result, 14, "%dMB", sz);

return result;
1048}

1050/*
* set up all the config files
*/
1053static void
1054setup_config(void)
1055{
char	  **conflines;
char		repltok[MAXPGPATH1024];
char		path[MAXPGPATH1024];
char	   *autoconflines[3];

fputs(_("creating configuration files ... ")("creating configuration files ... "), stdoutstdout);
fflush(stdoutstdout);

/* postgresql.conf */

conflines = readfile(conf_file);

snprintfpg_snprintf(repltok, sizeof(repltok), "max_connections = %d", n_connections);
conflines = replace_token(conflines, "#max_connections = 100", repltok);

if ((n_buffers * (BLCKSZ8192 / 1024)) % 1024 == 0)
1
Assuming the condition is false→
2
←
Taking false branch→
snprintfpg_snprintf(repltok, sizeof(repltok), "shared_buffers = %dMB",
		 (n_buffers * (BLCKSZ8192 / 1024)) / 1024);
else
snprintfpg_snprintf(repltok, sizeof(repltok), "shared_buffers = %dkB",
		 n_buffers * (BLCKSZ8192 / 1024));
conflines = replace_token(conflines, "#shared_buffers = 128MB", repltok);

1079#ifdef HAVE_UNIX_SOCKETS1
snprintfpg_snprintf(repltok, sizeof(repltok), "#unix_socket_directories = '%s'",
	 DEFAULT_PGSOCKET_DIR"/tmp");
1082#else
snprintfpg_snprintf(repltok, sizeof(repltok), "#unix_socket_directories = ''");
1084#endif
conflines = replace_token(conflines, "#unix_socket_directories = '/tmp'",
					  repltok);

1088#if DEF_PGPORT5432 != 5432
snprintfpg_snprintf(repltok, sizeof(repltok), "#port = %d", DEF_PGPORT5432);
conflines = replace_token(conflines, "#port = 5432", repltok);
1091#endif

/* set default max_wal_size and min_wal_size */
snprintfpg_snprintf(repltok, sizeof(repltok), "min_wal_size = %s",
	 pretty_wal_size(DEFAULT_MIN_WAL_SEGS5));
conflines = replace_token(conflines, "#min_wal_size = 80MB", repltok);

snprintfpg_snprintf(repltok, sizeof(repltok), "max_wal_size = %s",
	 pretty_wal_size(DEFAULT_MAX_WAL_SEGS64));
3
←
Calling 'pretty_wal_size'→
7
←
Returned allocated memory→
conflines = replace_token(conflines, "#max_wal_size = 1GB", repltok);
8
←
Potential memory leak

snprintfpg_snprintf(repltok, sizeof(repltok), "lc_messages = '%s'",
	 escape_quotes(lc_messages));
conflines = replace_token(conflines, "#lc_messages = 'C'", repltok);

snprintfpg_snprintf(repltok, sizeof(repltok), "lc_monetary = '%s'",
	 escape_quotes(lc_monetary));
conflines = replace_token(conflines, "#lc_monetary = 'C'", repltok);

snprintfpg_snprintf(repltok, sizeof(repltok), "lc_numeric = '%s'",
	 escape_quotes(lc_numeric));
conflines = replace_token(conflines, "#lc_numeric = 'C'", repltok);

snprintfpg_snprintf(repltok, sizeof(repltok), "lc_time = '%s'",
	 escape_quotes(lc_time));
conflines = replace_token(conflines, "#lc_time = 'C'", repltok);

switch (locale_date_order(lc_time))
{
case DATEORDER_YMD0:
	strcpy(repltok, "datestyle = 'iso, ymd'");
	break;
case DATEORDER_DMY1:
	strcpy(repltok, "datestyle = 'iso, dmy'");
	break;
case DATEORDER_MDY2:
default:
	strcpy(repltok, "datestyle = 'iso, mdy'");
	break;
}
conflines = replace_token(conflines, "#datestyle = 'iso, mdy'", repltok);

snprintfpg_snprintf(repltok, sizeof(repltok),
	 "default_text_search_config = 'pg_catalog.%s'",
	 escape_quotes(default_text_search_config));
conflines = replace_token(conflines,
					  "#default_text_search_config = 'pg_catalog.simple'",
					  repltok);

if (default_timezone)
{
snprintfpg_snprintf(repltok, sizeof(repltok), "timezone = '%s'",
		 escape_quotes(default_timezone));
conflines = replace_token(conflines, "#timezone = 'GMT'", repltok);
snprintfpg_snprintf(repltok, sizeof(repltok), "log_timezone = '%s'",
		 escape_quotes(default_timezone));
conflines = replace_token(conflines, "#log_timezone = 'GMT'", repltok);
}

snprintfpg_snprintf(repltok, sizeof(repltok), "dynamic_shared_memory_type = %s",
	 dynamic_shared_memory_type);
conflines = replace_token(conflines, "#dynamic_shared_memory_type = posix",
					  repltok);

1155#if DEFAULT_BACKEND_FLUSH_AFTER0 > 0
snprintfpg_snprintf(repltok, sizeof(repltok), "#backend_flush_after = %dkB",
	 DEFAULT_BACKEND_FLUSH_AFTER0 * (BLCKSZ8192 / 1024));
conflines = replace_token(conflines, "#backend_flush_after = 0",
					  repltok);
1160#endif

1162#if DEFAULT_BGWRITER_FLUSH_AFTER64 > 0
snprintfpg_snprintf(repltok, sizeof(repltok), "#bgwriter_flush_after = %dkB",
	 DEFAULT_BGWRITER_FLUSH_AFTER64 * (BLCKSZ8192 / 1024));
conflines = replace_token(conflines, "#bgwriter_flush_after = 0",
					  repltok);
1167#endif

1169#if DEFAULT_CHECKPOINT_FLUSH_AFTER32 > 0
snprintfpg_snprintf(repltok, sizeof(repltok), "#checkpoint_flush_after = %dkB",
	 DEFAULT_CHECKPOINT_FLUSH_AFTER32 * (BLCKSZ8192 / 1024));
conflines = replace_token(conflines, "#checkpoint_flush_after = 0",
					  repltok);
1174#endif

1176#ifndef USE_PREFETCH
conflines = replace_token(conflines,
					  "#effective_io_concurrency = 1",
					  "#effective_io_concurrency = 0");
1180#endif

1182#ifdef WIN32
conflines = replace_token(conflines,
					  "#update_process_title = on",
					  "#update_process_title = off");
1186#endif

/*
* Change password_encryption setting to md5 if md5 was chosen as an
* authentication method, unless scram-sha-256 was also chosen.
*/
if ((strcmp(authmethodlocal, "md5") == 0 &&
 strcmp(authmethodhost, "scram-sha-256") != 0) ||
(strcmp(authmethodhost, "md5") == 0 &&
 strcmp(authmethodlocal, "scram-sha-256") != 0))
{
conflines = replace_token(conflines,
						  "#password_encryption = scram-sha-256",
						  "password_encryption = md5");
}

/*
* If group access has been enabled for the cluster then it makes sense to
* ensure that the log files also allow group access.  Otherwise a backup
* from a user in the group would fail if the log files were not
* relocated.
*/
if (pg_dir_create_mode == PG_DIR_MODE_GROUP((0400|0200|0100) | (0400 >> 3) | (0100 >> 3)))
{
conflines = replace_token(conflines,
						  "#log_file_mode = 0600",
						  "log_file_mode = 0640");
}

snprintfpg_snprintf(path, sizeof(path), "%s/postgresql.conf", pg_data);

writefile(path, conflines);
if (chmod(path, pg_file_create_mode) != 0)
{
pg_log_error("could not change permissions of \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of \"%s\": %m"
, path); } while(0);
exit(1);
}

/*
* create the automatic configuration file to store the configuration
* parameters set by ALTER SYSTEM command. The parameters present in this
* file will override the value of parameters that exists before parse of
* this file.
*/
autoconflines[0] = pg_strdup("# Do not edit this file manually!\n");
autoconflines[1] = pg_strdup("# It will be overwritten by the ALTER SYSTEM command.\n");
autoconflines[2] = NULL((void*)0);

sprintfpg_sprintf(path, "%s/postgresql.auto.conf", pg_data);

writefile(path, autoconflines);
if (chmod(path, pg_file_create_mode) != 0)
{
pg_log_error("could not change permissions of \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of \"%s\": %m"
, path); } while(0);
exit(1);
}

free(conflines);


/* pg_hba.conf */

conflines = readfile(hba_file);

1250#ifndef HAVE_UNIX_SOCKETS1
conflines = filter_lines_with_token(conflines, "@remove-line-for-nolocal@");
1252#else
conflines = replace_token(conflines, "@remove-line-for-nolocal@", "");
1254#endif

1256#ifdef HAVE_IPV61

/*
* Probe to see if there is really any platform support for IPv6, and
* comment out the relevant pg_hba line if not.  This avoids runtime
* warnings if getaddrinfo doesn't actually cope with IPv6.  Particularly
* useful on Windows, where executables built on a machine with IPv6 may
* have to run on a machine without.
*/
{
struct addrinfo *gai_result;
struct addrinfo hints;
int			err = 0;

1270#ifdef WIN32
/* need to call WSAStartup before calling getaddrinfo */
WSADATA		wsaData;

err = WSAStartup(MAKEWORD(2, 2), &wsaData);
1275#endif

/* for best results, this code should match parse_hba_line() */
hints.ai_flags = AI_NUMERICHOST0x0004;
hints.ai_family = AF_UNSPEC0;
hints.ai_socktype = 0;
hints.ai_protocol = 0;
hints.ai_addrlen = 0;
hints.ai_canonname = NULL((void*)0);
hints.ai_addr = NULL((void*)0);
hints.ai_next = NULL((void*)0);

if (err != 0 ||
	getaddrinfo("::1", NULL((void*)0), &hints, &gai_result) != 0)
{
	conflines = replace_token(conflines,
							  "host    all             all             ::1",
							  "#host    all             all             ::1");
	conflines = replace_token(conflines,
							  "host    replication     all             ::1",
							  "#host    replication     all             ::1");
}
}
1298#else							/* !HAVE_IPV6 */
/* If we didn't compile IPV6 support at all, always comment it out */
conflines = replace_token(conflines,
					  "host    all             all             ::1",
					  "#host    all             all             ::1");
conflines = replace_token(conflines,
					  "host    replication     all             ::1",
					  "#host    replication     all             ::1");
1306#endif							/* HAVE_IPV6 */

/* Replace default authentication methods */
conflines = replace_token(conflines,
					  "@authmethodhost@",
					  authmethodhost);
conflines = replace_token(conflines,
					  "@authmethodlocal@",
					  authmethodlocal);

conflines = replace_token(conflines,
					  "@authcomment@",
					  (strcmp(authmethodlocal, "trust") == 0 || strcmp(authmethodhost, "trust") == 0) ? AUTHTRUST_WARNING"# CAUTION: Configuring the system for local \"trust\" authentication\n"
 "# allows any local user to connect as any PostgreSQL user, including\n"
 "# the database superuser.  If you do not trust all your local users,\n"
 "# use another authentication method.\n" : "");

snprintfpg_snprintf(path, sizeof(path), "%s/pg_hba.conf", pg_data);

writefile(path, conflines);
if (chmod(path, pg_file_create_mode) != 0)
{
pg_log_error("could not change permissions of \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of \"%s\": %m"
, path); } while(0);
exit(1);
}

free(conflines);

/* pg_ident.conf */

conflines = readfile(ident_file);

snprintfpg_snprintf(path, sizeof(path), "%s/pg_ident.conf", pg_data);

writefile(path, conflines);
if (chmod(path, pg_file_create_mode) != 0)
{
pg_log_error("could not change permissions of \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of \"%s\": %m"
, path); } while(0);
exit(1);
}

free(conflines);

check_ok();
1347}


1350/*
* run the BKI script in bootstrap mode to create template1
*/
1353static void
1354bootstrap_template1(void)
1355{
PG_CMD_DECLchar cmd[1024]; FILE *cmdfd;
char	  **line;
char	  **bki_lines;
char		headerline[MAXPGPATH1024];
char		buf[64];

printf(_("running bootstrap script ... "))pg_printf(("running bootstrap script ... "));
fflush(stdoutstdout);

bki_lines = readfile(bki_file);

/* Check that bki file appears to be of the right version */

snprintfpg_snprintf(headerline, sizeof(headerline), "# PostgreSQL %s\n",
	 PG_MAJORVERSION"15");

if (strcmp(headerline, *bki_lines) != 0)
{
pg_log_error("input file \"%s\" does not belong to PostgreSQL %s",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "input file \"%s\" does not belong to PostgreSQL %s"
, bki_file, "15devel"); } while(0)
			 bki_file, PG_VERSION)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "input file \"%s\" does not belong to PostgreSQL %s"
, bki_file, "15devel"); } while(0);
fprintfpg_fprintf(stderrstderr,
		_("Check your installation or specify the correct path "("Check your installation or specify the correct path " "using the option -L.\n"
)
		  "using the option -L.\n")("Check your installation or specify the correct path " "using the option -L.\n"
));
exit(1);
}

/* Substitute for various symbols used in the BKI file */

sprintfpg_sprintf(buf, "%d", NAMEDATALEN64);
bki_lines = replace_token(bki_lines, "NAMEDATALEN", buf);

sprintfpg_sprintf(buf, "%d", (int) sizeof(Pointer));
bki_lines = replace_token(bki_lines, "SIZEOF_POINTER", buf);

bki_lines = replace_token(bki_lines, "ALIGNOF_POINTER",
					  (sizeof(Pointer) == 4) ? "i" : "d");

bki_lines = replace_token(bki_lines, "FLOAT8PASSBYVAL",
					  FLOAT8PASSBYVAL1 ? "true" : "false");

bki_lines = replace_token(bki_lines, "POSTGRES",
					  escape_quotes_bki(username));

bki_lines = replace_token(bki_lines, "ENCODING",
					  encodingid_to_string(encodingid));

bki_lines = replace_token(bki_lines, "LC_COLLATE",
					  escape_quotes_bki(lc_collate));

bki_lines = replace_token(bki_lines, "LC_CTYPE",
					  escape_quotes_bki(lc_ctype));

/* Also ensure backend isn't confused by this environment var: */
unsetenv("PGCLIENTENCODING");

snprintfpg_snprintf(cmd, sizeof(cmd),
	 "\"%s\" --boot -X %d %s %s %s %s",
	 backend_exec,
	 wal_segment_size_mb * (1024 * 1024),
	 data_checksums ? "-k" : "",
	 boot_options, extra_options,
	 debug ? "-d 5" : "");


PG_CMD_OPENdo { cmdfd = popen_check(cmd, "w"); if (cmdfd == ((void*)0)) exit
(1); } while (0);

for (line = bki_lines; *line != NULL((void*)0); line++)
{
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
free(*line);
}

PG_CMD_CLOSEdo { if (pclose_check(cmdfd)) exit(1); } while (0);

free(bki_lines);

check_ok();
1433}

1435/*
* set up the shadow password table
*/
1438static void
1439setup_auth(FILE *cmdfd)
1440{
const char *const *line;
static const char *const pg_authid_setup[] = {
/*
 * The authid table shouldn't be readable except through views, to
 * ensure passwords are not publicly visible.
 */
"REVOKE ALL ON pg_authid FROM public;\n\n",
NULL((void*)0)
};

for (line = pg_authid_setup; *line != NULL((void*)0); line++)
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);

if (superuser_password)
PG_CMD_PRINTF("ALTER USER \"%s\" WITH PASSWORD E'%s';\n\n",do { if (pg_fprintf(cmdfd, "ALTER USER \"%s\" WITH PASSWORD E'%s';\n\n"
, username, escape_quotes(superuser_password)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0)
			  username, escape_quotes(superuser_password))do { if (pg_fprintf(cmdfd, "ALTER USER \"%s\" WITH PASSWORD E'%s';\n\n"
, username, escape_quotes(superuser_password)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0);
1457}

1459/*
* get the superuser password if required
*/
1462static void
1463get_su_pwd(void)
1464{
char	   *pwd1;

if (pwprompt)
{
/*
 * Read password from terminal
 */
char	   *pwd2;

printf("\n")pg_printf("\n");
fflush(stdoutstdout);
pwd1 = simple_prompt("Enter new superuser password: ", false0);
pwd2 = simple_prompt("Enter it again: ", false0);
if (strcmp(pwd1, pwd2) != 0)
{
	fprintfpg_fprintf(stderrstderr, _("Passwords didn't match.\n")("Passwords didn't match.\n"));
	exit(1);
}
free(pwd2);
}
else
{
/*
 * Read password from file
 *
 * Ideally this should insist that the file not be world-readable.
 * However, this option is mainly intended for use on Windows where
 * file permissions may not exist at all, so we'll skip the paranoia
 * for now.
 */
FILE	   *pwf = fopen(pwfilename, "r");

if (!pwf)
{
	pg_log_error("could not open file \"%s\" for reading: %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for reading: %m"
, pwfilename); } while(0)
				 pwfilename)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not open file \"%s\" for reading: %m"
, pwfilename); } while(0);
	exit(1);
}
pwd1 = pg_get_line(pwf, NULL((void*)0));
if (!pwd1)
{
	if (ferror(pwf))
		pg_log_error("could not read password from file \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not read password from file \"%s\": %m"
, pwfilename); } while(0)
					 pwfilename)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not read password from file \"%s\": %m"
, pwfilename); } while(0);
	else
		pg_log_error("password file \"%s\" is empty",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "password file \"%s\" is empty"
, pwfilename); } while(0)
					 pwfilename)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "password file \"%s\" is empty"
, pwfilename); } while(0);
	exit(1);
}
fclose(pwf);

(void) pg_strip_crlf(pwd1);
}

superuser_password = pwd1;
1520}

1522/*
* set up pg_depend
*/
1525static void
1526setup_depend(FILE *cmdfd)
1527{
const char *const *line;
static const char *const pg_depend_setup[] = {
/*
 * Advance the OID counter so that subsequently-created objects aren't
 * pinned.
 */
"SELECT pg_stop_making_pinned_objects();\n\n",
NULL((void*)0)
};

for (line = pg_depend_setup; *line != NULL((void*)0); line++)
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
1540}

1542/*
* Run external file
*/
1545static void
1546setup_run_file(FILE *cmdfd, const char *filename)
1547{
char	  **lines;

lines = readfile(filename);

for (char **line = lines; *line != NULL((void*)0); line++)
{
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
free(*line);
}

PG_CMD_PUTS("\n\n")do { if (fputs("\n\n", cmdfd) < 0 || fflush(cmdfd) < 0)
 output_failed = 1, output_errno = (*__errno_location ()); } while
 (0);

free(lines);
1561}

1563/*
* fill in extra description data
*/
1566static void
1567setup_description(FILE *cmdfd)
1568{
/* Create default descriptions for operator implementation functions */
PG_CMD_PUTS("WITH funcdescs AS ( "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"SELECT p.oid as p_oid, o.oid as o_oid, oprname "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"INSERT INTO pg_description "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"  SELECT p_oid, 'pg_proc'::regclass, 0, "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"    'implementation of ' || oprname || ' operator' "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"  FROM funcdescs "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"  WHERE NOT EXISTS (SELECT 1 FROM pg_description "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"  AND NOT EXISTS (SELECT 1 FROM pg_description "do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0)
		"         AND description LIKE 'deprecated%');\n\n")do { if (fputs("WITH funcdescs AS ( " "SELECT p.oid as p_oid, o.oid as o_oid, oprname "
 "FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid ) " "INSERT INTO pg_description "
 "  SELECT p_oid, 'pg_proc'::regclass, 0, " "    'implementation of ' || oprname || ' operator' "
 "  FROM funcdescs " "  WHERE NOT EXISTS (SELECT 1 FROM pg_description "
 "   WHERE objoid = p_oid AND classoid = 'pg_proc'::regclass) "
 "  AND NOT EXISTS (SELECT 1 FROM pg_description " "   WHERE objoid = o_oid AND classoid = 'pg_operator'::regclass"
 "         AND description LIKE 'deprecated%');\n\n", cmdfd) <
|| fflush(cmdfd) < 0) output_failed = 1, output_errno =
 (*__errno_location ()); } while (0);
1582}

1584/*
* populate pg_collation
*/
1587static void
1588setup_collation(FILE *cmdfd)
1589{
/*
* Add an SQL-standard name.  We don't want to pin this, so it doesn't go
* in pg_collation.h.  But add it before reading system collations, so
* that it wins if libc defines a locale named ucs_basic.
*/
PG_CMD_PRINTF("INSERT INTO pg_collation (oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype)"do { if (pg_fprintf(cmdfd, "INSERT INTO pg_collation (oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype)"
 "VALUES (pg_nextoid('pg_catalog.pg_collation', 'oid', 'pg_catalog.pg_collation_oid_index'), 'ucs_basic', 'pg_catalog'::regnamespace, %u, '%c', true, %d, 'C', 'C');\n\n"
, 10, 'c', PG_UTF8) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0)
		  "VALUES (pg_nextoid('pg_catalog.pg_collation', 'oid', 'pg_catalog.pg_collation_oid_index'), 'ucs_basic', 'pg_catalog'::regnamespace, %u, '%c', true, %d, 'C', 'C');\n\n",do { if (pg_fprintf(cmdfd, "INSERT INTO pg_collation (oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype)"
 "VALUES (pg_nextoid('pg_catalog.pg_collation', 'oid', 'pg_catalog.pg_collation_oid_index'), 'ucs_basic', 'pg_catalog'::regnamespace, %u, '%c', true, %d, 'C', 'C');\n\n"
, 10, 'c', PG_UTF8) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0)
		  BOOTSTRAP_SUPERUSERID, COLLPROVIDER_LIBC, PG_UTF8)do { if (pg_fprintf(cmdfd, "INSERT INTO pg_collation (oid, collname, collnamespace, collowner, collprovider, collisdeterministic, collencoding, collcollate, collctype)"
 "VALUES (pg_nextoid('pg_catalog.pg_collation', 'oid', 'pg_catalog.pg_collation_oid_index'), 'ucs_basic', 'pg_catalog'::regnamespace, %u, '%c', true, %d, 'C', 'C');\n\n"
, 10, 'c', PG_UTF8) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);

/* Now import all collations we can find in the operating system */
PG_CMD_PUTS("SELECT pg_import_system_collations('pg_catalog');\n\n")do { if (fputs("SELECT pg_import_system_collations('pg_catalog');\n\n"
, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed = 1, output_errno
 = (*__errno_location ()); } while (0);
1601}

1603/*
* Set up privileges
*
* We mark most system catalogs as world-readable.  We don't currently have
* to touch functions, languages, or databases, because their default
* permissions are OK.
*
* Some objects may require different permissions by default, so we
* make sure we don't overwrite privilege sets that have already been
* set (NOT NULL).
*
* Also populate pg_init_privs to save what the privileges are at init
* time.  This is used by pg_dump to allow users to change privileges
* on catalog objects and to have those privilege changes preserved
* across dump/reload and pg_upgrade.
*
* Note that pg_init_privs is only for per-database objects and therefore
* we don't include databases or tablespaces.
*/
1622static void
1623setup_privileges(FILE *cmdfd)
1624{
char	  **line;
char	  **priv_lines;
static char *privileges_setup[] = {
"UPDATE pg_class "
"  SET relacl = (SELECT array_agg(a.acl) FROM "
" (SELECT E'=r/\"$POSTGRES_SUPERUSERNAME\"' as acl "
"  UNION SELECT unnest(pg_catalog.acldefault("
"    CASE WHEN relkind = " CppAsString2(RELKIND_SEQUENCE)"'S'" " THEN 's' "
"         ELSE 'r' END::\"char\"," CppAsString2(BOOTSTRAP_SUPERUSERID)"10" "::oid))"
" ) as a) "
"  WHERE relkind IN (" CppAsString2(RELKIND_RELATION)"'r'" ", "
CppAsString2(RELKIND_VIEW)"'v'" ", " CppAsString2(RELKIND_MATVIEW)"'m'" ", "
CppAsString2(RELKIND_SEQUENCE)"'S'" ")"
"  AND relacl IS NULL;\n\n",
"GRANT USAGE ON SCHEMA pg_catalog, public TO PUBLIC;\n\n",
"REVOKE ALL ON pg_largeobject FROM PUBLIC;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_class'),"
"        0,"
"        relacl,"
"        'i'"
"    FROM"
"        pg_class"
"    WHERE"
"        relacl IS NOT NULL"
"        AND relkind IN (" CppAsString2(RELKIND_RELATION)"'r'" ", "
CppAsString2(RELKIND_VIEW)"'v'" ", " CppAsString2(RELKIND_MATVIEW)"'m'" ", "
CppAsString2(RELKIND_SEQUENCE)"'S'" ");\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        pg_class.oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_class'),"
"        pg_attribute.attnum,"
"        pg_attribute.attacl,"
"        'i'"
"    FROM"
"        pg_class"
"        JOIN pg_attribute ON (pg_class.oid = pg_attribute.attrelid)"
"    WHERE"
"        pg_attribute.attacl IS NOT NULL"
"        AND pg_class.relkind IN (" CppAsString2(RELKIND_RELATION)"'r'" ", "
CppAsString2(RELKIND_VIEW)"'v'" ", " CppAsString2(RELKIND_MATVIEW)"'m'" ", "
CppAsString2(RELKIND_SEQUENCE)"'S'" ");\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_proc'),"
"        0,"
"        proacl,"
"        'i'"
"    FROM"
"        pg_proc"
"    WHERE"
"        proacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_type'),"
"        0,"
"        typacl,"
"        'i'"
"    FROM"
"        pg_type"
"    WHERE"
"        typacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_language'),"
"        0,"
"        lanacl,"
"        'i'"
"    FROM"
"        pg_language"
"    WHERE"
"        lanacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE "
"         relname = 'pg_largeobject_metadata'),"
"        0,"
"        lomacl,"
"        'i'"
"    FROM"
"        pg_largeobject_metadata"
"    WHERE"
"        lomacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE relname = 'pg_namespace'),"
"        0,"
"        nspacl,"
"        'i'"
"    FROM"
"        pg_namespace"
"    WHERE"
"        nspacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class WHERE "
"         relname = 'pg_foreign_data_wrapper'),"
"        0,"
"        fdwacl,"
"        'i'"
"    FROM"
"        pg_foreign_data_wrapper"
"    WHERE"
"        fdwacl IS NOT NULL;\n\n",
"INSERT INTO pg_init_privs "
"  (objoid, classoid, objsubid, initprivs, privtype)"
"    SELECT"
"        oid,"
"        (SELECT oid FROM pg_class "
"         WHERE relname = 'pg_foreign_server'),"
"        0,"
"        srvacl,"
"        'i'"
"    FROM"
"        pg_foreign_server"
"    WHERE"
"        srvacl IS NOT NULL;\n\n",
NULL((void*)0)
};

priv_lines = replace_token(privileges_setup, "$POSTGRES_SUPERUSERNAME",
					   escape_quotes(username));
for (line = priv_lines; *line != NULL((void*)0); line++)
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
1766}

1768/*
* extract the strange version of version required for information schema
* (09.08.0007abc)
*/
1772static void
1773set_info_version(void)
1774{
char	   *letterversion;
long		major = 0,
		minor = 0,
		micro = 0;
char	   *endptr;
char	   *vstr = pg_strdup(PG_VERSION"15devel");
char	   *ptr;

ptr = vstr + (strlen(vstr) - 1);
while (ptr != vstr && (*ptr < '0' || *ptr > '9'))
ptr--;
letterversion = ptr + 1;
major = strtol(vstr, &endptr, 10);
if (*endptr)
minor = strtol(endptr + 1, &endptr, 10);
if (*endptr)
micro = strtol(endptr + 1, &endptr, 10);
snprintfpg_snprintf(infoversion, sizeof(infoversion), "%02ld.%02ld.%04ld%s",
	 major, minor, micro, letterversion);
1794}

1796/*
* load info schema and populate from features file
*/
1799static void
1800setup_schema(FILE *cmdfd)
1801{
setup_run_file(cmdfd, info_schema_file);

PG_CMD_PRINTF("UPDATE information_schema.sql_implementation_info "do { if (pg_fprintf(cmdfd, "UPDATE information_schema.sql_implementation_info "
 "  SET character_value = '%s' " "  WHERE implementation_info_name = 'DBMS VERSION';\n\n"
, infoversion) < 0 || fflush(cmdfd) < 0) output_failed =
 1, output_errno = (*__errno_location ()); } while (0)
		  "  SET character_value = '%s' "do { if (pg_fprintf(cmdfd, "UPDATE information_schema.sql_implementation_info "
 "  SET character_value = '%s' " "  WHERE implementation_info_name = 'DBMS VERSION';\n\n"
, infoversion) < 0 || fflush(cmdfd) < 0) output_failed =
 1, output_errno = (*__errno_location ()); } while (0)
		  "  WHERE implementation_info_name = 'DBMS VERSION';\n\n",do { if (pg_fprintf(cmdfd, "UPDATE information_schema.sql_implementation_info "
 "  SET character_value = '%s' " "  WHERE implementation_info_name = 'DBMS VERSION';\n\n"
, infoversion) < 0 || fflush(cmdfd) < 0) output_failed =
 1, output_errno = (*__errno_location ()); } while (0)
		  infoversion)do { if (pg_fprintf(cmdfd, "UPDATE information_schema.sql_implementation_info "
 "  SET character_value = '%s' " "  WHERE implementation_info_name = 'DBMS VERSION';\n\n"
, infoversion) < 0 || fflush(cmdfd) < 0) output_failed =
 1, output_errno = (*__errno_location ()); } while (0);

PG_CMD_PRINTF("COPY information_schema.sql_features "do { if (pg_fprintf(cmdfd, "COPY information_schema.sql_features "
 "  (feature_id, feature_name, sub_feature_id, " "  sub_feature_name, is_supported, comments) "
 " FROM E'%s';\n\n", escape_quotes(features_file)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0)
		  "  (feature_id, feature_name, sub_feature_id, "do { if (pg_fprintf(cmdfd, "COPY information_schema.sql_features "
 "  (feature_id, feature_name, sub_feature_id, " "  sub_feature_name, is_supported, comments) "
 " FROM E'%s';\n\n", escape_quotes(features_file)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0)
		  "  sub_feature_name, is_supported, comments) "do { if (pg_fprintf(cmdfd, "COPY information_schema.sql_features "
 "  (feature_id, feature_name, sub_feature_id, " "  sub_feature_name, is_supported, comments) "
 " FROM E'%s';\n\n", escape_quotes(features_file)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0)
		  " FROM E'%s';\n\n",do { if (pg_fprintf(cmdfd, "COPY information_schema.sql_features "
 "  (feature_id, feature_name, sub_feature_id, " "  sub_feature_name, is_supported, comments) "
 " FROM E'%s';\n\n", escape_quotes(features_file)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0)
		  escape_quotes(features_file))do { if (pg_fprintf(cmdfd, "COPY information_schema.sql_features "
 "  (feature_id, feature_name, sub_feature_id, " "  sub_feature_name, is_supported, comments) "
 " FROM E'%s';\n\n", escape_quotes(features_file)) < 0 || fflush
(cmdfd) < 0) output_failed = 1, output_errno = (*__errno_location
 ()); } while (0);
1814}

1816/*
* load PL/pgSQL server-side language
*/
1819static void
1820load_plpgsql(FILE *cmdfd)
1821{
PG_CMD_PUTS("CREATE EXTENSION plpgsql;\n\n")do { if (fputs("CREATE EXTENSION plpgsql;\n\n", cmdfd) < 0
 || fflush(cmdfd) < 0) output_failed = 1, output_errno = (
*__errno_location ()); } while (0);
1823}

1825/*
* clean everything up in template1
*/
1828static void
1829vacuum_db(FILE *cmdfd)
1830{
/* Run analyze before VACUUM so the statistics are frozen. */
PG_CMD_PUTS("ANALYZE;\n\nVACUUM FREEZE;\n\n")do { if (fputs("ANALYZE;\n\nVACUUM FREEZE;\n\n", cmdfd) < 0
 || fflush(cmdfd) < 0) output_failed = 1, output_errno = (
*__errno_location ()); } while (0);
1833}

1835/*
* copy template1 to template0
*/
1838static void
1839make_template0(FILE *cmdfd)
1840{
const char *const *line;

/*
* pg_upgrade tries to preserve database OIDs across upgrades. It's smart
* enough to drop and recreate a conflicting database with the same name,
* but if the same OID were used for one system-created database in the
* old cluster and a different system-created database in the new cluster,
* it would fail. To avoid that, assign a fixed OID to template0 rather
* than letting the server choose one.
*
* (Note that, while the user could have dropped and recreated these
* objects in the old cluster, the problem scenario only exists if the OID
* that is in use in the old cluster is also used in the new cluster - and
* the new cluster should be the result of a fresh initdb.)
*/
static const char *const template0_setup[] = {
"CREATE DATABASE template0 IS_TEMPLATE = true ALLOW_CONNECTIONS = false OID = "
CppAsString2(Template0ObjectId)"4" ";\n\n",

/*
 * Explicitly revoke public create-schema and create-temp-table
 * privileges in template1 and template0; else the latter would be on
 * by default
 */
"REVOKE CREATE,TEMPORARY ON DATABASE template1 FROM public;\n\n",
"REVOKE CREATE,TEMPORARY ON DATABASE template0 FROM public;\n\n",

"COMMENT ON DATABASE template0 IS 'unmodifiable empty database';\n\n",

/*
 * Finally vacuum to clean up dead rows in pg_database
 */
"VACUUM pg_database;\n\n",
NULL((void*)0)
};

for (line = template0_setup; *line; line++)
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
1879}

1881/*
* copy template1 to postgres
*/
1884static void
1885make_postgres(FILE *cmdfd)
1886{
const char *const *line;

/* Assign a fixed OID to postgres, for the same reasons as template0 */
static const char *const postgres_setup[] = {
"CREATE DATABASE postgres OID = " CppAsString2(PostgresObjectId)"5" ";\n\n",
"COMMENT ON DATABASE postgres IS 'default administrative connection database';\n\n",
NULL((void*)0)
};

for (line = postgres_setup; *line; line++)
PG_CMD_PUTS(*line)do { if (fputs(*line, cmdfd) < 0 || fflush(cmdfd) < 0) output_failed
 = 1, output_errno = (*__errno_location ()); } while (0);
1898}

1900/*
* signal handler in case we are interrupted.
*
* The Windows runtime docs at
* https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/signal
* specifically forbid a number of things being done from a signal handler,
* including IO, memory allocation and system calls, and only allow jmpbuf
* if you are handling SIGFPE.
*
* I avoided doing the forbidden things by setting a flag instead of calling
* exit() directly.
*
* Also note the behaviour of Windows with SIGINT, which says this:
*  SIGINT is not supported for any Win32 application. When a CTRL+C interrupt
*  occurs, Win32 operating systems generate a new thread to specifically
*  handle that interrupt. This can cause a single-thread application, such as
*  one in UNIX, to become multithreaded and cause unexpected behavior.
*
* I have no idea how to handle this. (Strange they call UNIX an application!)
* So this will need some testing on Windows.
*/
1921static void
1922trapsig(int signum)
1923{
/* handle systems that reset the handler, like Windows (grr) */
pqsignal(signum, trapsig);
caught_signal = true1;
1927}

1929/*
* call exit() if we got a signal, or else output "ok".
*/
1932static void
1933check_ok(void)
1934{
if (caught_signal)
{
printf(_("caught signal\n"))pg_printf(("caught signal\n"));
fflush(stdoutstdout);
exit(1);
}
else if (output_failed)
{
printf(_("could not write to child process: %s\n"),pg_printf(("could not write to child process: %s\n"), pg_strerror
(output_errno))
	   strerror(output_errno))pg_printf(("could not write to child process: %s\n"), pg_strerror
(output_errno));
fflush(stdoutstdout);
exit(1);
}
else
{
/* all seems well */
printf(_("ok\n"))pg_printf(("ok\n"));
fflush(stdoutstdout);
}
1954}

1956/* Hack to suppress a warning about %x from some versions of gcc */
1957static inline size_t
1958my_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)
1959{
return strftime(s, max, fmt, tm);
1961}

1963/*
* Determine likely date order from locale
*/
1966static int
1967locale_date_order(const char *locale)
1968{
struct tm	testtime;
char		buf[128];
char	   *posD;
char	   *posM;
char	   *posY;
char	   *save;
size_t		res;
int			result;

result = DATEORDER_MDY2;		/* default */

save = setlocale(LC_TIME2, NULL((void*)0));
if (!save)
return result;
save = pg_strdup(save);

setlocale(LC_TIME2, locale);

memset(&testtime, 0, sizeof(testtime));
testtime.tm_mday = 22;
testtime.tm_mon = 10;		/* November, should come out as "11" */
testtime.tm_year = 133;		/* 2033 */

res = my_strftime(buf, sizeof(buf), "%x", &testtime);

setlocale(LC_TIME2, save);
free(save);

if (res == 0)
return result;

posM = strstr(buf, "11");
posD = strstr(buf, "22");
posY = strstr(buf, "33");

if (!posM || !posD || !posY)
return result;

if (posY < posM && posM < posD)
result = DATEORDER_YMD0;
else if (posD < posM)
result = DATEORDER_DMY1;
else
result = DATEORDER_MDY2;

return result;
2015}

2017/*
* Verify that locale name is valid for the locale category.
*
* If successful, and canonname isn't NULL, a malloc'd copy of the locale's
* canonical name is stored there.  This is especially useful for figuring out
* what locale name "" means (ie, the environment value).  (Actually,
* it seems that on most implementations that's the only thing it's good for;
* we could wish that setlocale gave back a canonically spelled version of
* the locale name, but typically it doesn't.)
*
* this should match the backend's check_locale() function
*/
2029static void
2030check_locale_name(int category, const char *locale, char **canonname)
2031{
char	   *save;
char	   *res;

if (canonname)
*canonname = NULL((void*)0);		/* in case of failure */

save = setlocale(category, NULL((void*)0));
if (!save)
{
pg_log_error("setlocale() failed")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "setlocale() failed")
; } while(0);
exit(1);
}

/* save may be pointing at a modifiable scratch variable, so copy it. */
save = pg_strdup(save);

/* for setlocale() call */
if (!locale)
locale = "";

/* set the locale with setlocale, to see if it accepts it. */
res = setlocale(category, locale);

/* save canonical name if requested. */
if (res && canonname)
*canonname = pg_strdup(res);

/* restore old value. */
if (!setlocale(category, save))
{
pg_log_error("failed to restore old locale \"%s\"", save)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "failed to restore old locale \"%s\""
, save); } while(0);
exit(1);
}
free(save);

/* complain if locale wasn't valid */
if (res == NULL((void*)0))
{
if (*locale)
	pg_log_error("invalid locale name \"%s\"", locale)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "invalid locale name \"%s\""
, locale); } while(0);
else
{
	/*
	 * If no relevant switch was given on command line, locale is an
	 * empty string, which is not too helpful to report.  Presumably
	 * setlocale() found something it did not like in the environment.
	 * Ideally we'd report the bad environment variable, but since
	 * setlocale's behavior is implementation-specific, it's hard to
	 * be sure what it didn't like.  Print a safe generic message.
	 */
	pg_log_error("invalid locale settings; check LANG and LC_* environment variables")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "invalid locale settings; check LANG and LC_* environment variables"
); } while(0);
}
exit(1);
}
2086}

2088/*
* check if the chosen encoding matches the encoding required by the locale
*
* this should match the similar check in the backend createdb() function
*/
2093static bool_Bool
2094check_locale_encoding(const char *locale, int user_enc)
2095{
int			locale_enc;

locale_enc = pg_get_encoding_from_locale(locale, true1);

/* See notes in createdb() to understand these tests */
if (!(locale_enc == user_enc ||
  locale_enc == PG_SQL_ASCII ||
  locale_enc == -1 ||
2104#ifdef WIN32
  user_enc == PG_UTF8 ||
2106#endif
  user_enc == PG_SQL_ASCII))
{
pg_log_error("encoding mismatch")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "encoding mismatch");
 } while(0);
fprintfpg_fprintf(stderrstderr,
		_("The encoding you selected (%s) and the encoding that the\n"("The encoding you selected (%s) and the encoding that the\n"
 "selected locale uses (%s) do not match.  This would lead to\n"
 "misbehavior in various character string processing functions.\n"
 "Rerun %s and either do not specify an encoding explicitly,\n"
 "or choose a matching combination.\n")
		  "selected locale uses (%s) do not match.  This would lead to\n"("The encoding you selected (%s) and the encoding that the\n"
 "selected locale uses (%s) do not match.  This would lead to\n"
 "misbehavior in various character string processing functions.\n"
 "Rerun %s and either do not specify an encoding explicitly,\n"
 "or choose a matching combination.\n")
		  "misbehavior in various character string processing functions.\n"("The encoding you selected (%s) and the encoding that the\n"
 "selected locale uses (%s) do not match.  This would lead to\n"
 "misbehavior in various character string processing functions.\n"
 "Rerun %s and either do not specify an encoding explicitly,\n"
 "or choose a matching combination.\n")
		  "Rerun %s and either do not specify an encoding explicitly,\n"("The encoding you selected (%s) and the encoding that the\n"
 "selected locale uses (%s) do not match.  This would lead to\n"
 "misbehavior in various character string processing functions.\n"
 "Rerun %s and either do not specify an encoding explicitly,\n"
 "or choose a matching combination.\n")
		  "or choose a matching combination.\n")("The encoding you selected (%s) and the encoding that the\n"
 "selected locale uses (%s) do not match.  This would lead to\n"
 "misbehavior in various character string processing functions.\n"
 "Rerun %s and either do not specify an encoding explicitly,\n"
 "or choose a matching combination.\n"),
		pg_encoding_to_char(user_enc),
		pg_encoding_to_char(locale_enc),
		progname);
return false0;
}
return true1;
2122}

2124/*
* set up the locale variables
*
* assumes we have called setlocale(LC_ALL, "") -- see set_pglocale_pgservice
*/
2129static void
2130setlocales(void)
2131{
char	   *canonname;

/* set empty lc_* values to locale config if set */

if (locale)
{
if (!lc_ctype)
	lc_ctype = locale;
if (!lc_collate)
	lc_collate = locale;
if (!lc_numeric)
	lc_numeric = locale;
if (!lc_time)
	lc_time = locale;
if (!lc_monetary)
	lc_monetary = locale;
if (!lc_messages)
	lc_messages = locale;
}

/*
* canonicalize locale names, and obtain any missing values from our
* current environment
*/

check_locale_name(LC_CTYPE0, lc_ctype, &canonname);
lc_ctype = canonname;
check_locale_name(LC_COLLATE3, lc_collate, &canonname);
lc_collate = canonname;
check_locale_name(LC_NUMERIC1, lc_numeric, &canonname);
lc_numeric = canonname;
check_locale_name(LC_TIME2, lc_time, &canonname);
lc_time = canonname;
check_locale_name(LC_MONETARY4, lc_monetary, &canonname);
lc_monetary = canonname;
2167#if defined(LC_MESSAGES5) && !defined(WIN32)
check_locale_name(LC_MESSAGES5, lc_messages, &canonname);
lc_messages = canonname;
2170#else
/* when LC_MESSAGES is not available, use the LC_CTYPE setting */
check_locale_name(LC_CTYPE0, lc_messages, &canonname);
lc_messages = canonname;
2174#endif
2175}

2177/*
* print help text
*/
2180static void
2181usage(const char *progname)
2182{
printf(_("%s initializes a PostgreSQL database cluster.\n\n"), progname)pg_printf(("%s initializes a PostgreSQL database cluster.\n\n"
), progname);
printf(_("Usage:\n"))pg_printf(("Usage:\n"));
printf(_("  %s [OPTION]... [DATADIR]\n"), progname)pg_printf(("  %s [OPTION]... [DATADIR]\n"), progname);
printf(_("\nOptions:\n"))pg_printf(("\nOptions:\n"));
printf(_("  -A, --auth=METHOD         default authentication method for local connections\n"))pg_printf(("  -A, --auth=METHOD         default authentication method for local connections\n"
));
printf(_("      --auth-host=METHOD    default authentication method for local TCP/IP connections\n"))pg_printf(("      --auth-host=METHOD    default authentication method for local TCP/IP connections\n"
));
printf(_("      --auth-local=METHOD   default authentication method for local-socket connections\n"))pg_printf(("      --auth-local=METHOD   default authentication method for local-socket connections\n"
));
printf(_(" [-D, --pgdata=]DATADIR     location for this database cluster\n"))pg_printf((" [-D, --pgdata=]DATADIR     location for this database cluster\n"
));
printf(_("  -E, --encoding=ENCODING   set default encoding for new databases\n"))pg_printf(("  -E, --encoding=ENCODING   set default encoding for new databases\n"
));
printf(_("  -g, --allow-group-access  allow group read/execute on data directory\n"))pg_printf(("  -g, --allow-group-access  allow group read/execute on data directory\n"
));
printf(_("  -k, --data-checksums      use data page checksums\n"))pg_printf(("  -k, --data-checksums      use data page checksums\n"
));
printf(_("      --locale=LOCALE       set default locale for new databases\n"))pg_printf(("      --locale=LOCALE       set default locale for new databases\n"
));
printf(_("      --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"pg_printf(("      --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
 "      --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n" "                            set default locale in the respective category for\n"
 "                            new databases (default taken from environment)\n"
))
	 "      --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n"pg_printf(("      --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
 "      --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n" "                            set default locale in the respective category for\n"
 "                            new databases (default taken from environment)\n"
))
	 "                            set default locale in the respective category for\n"pg_printf(("      --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
 "      --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n" "                            set default locale in the respective category for\n"
 "                            new databases (default taken from environment)\n"
))
	 "                            new databases (default taken from environment)\n"))pg_printf(("      --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
 "      --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n" "                            set default locale in the respective category for\n"
 "                            new databases (default taken from environment)\n"
));
printf(_("      --no-locale           equivalent to --locale=C\n"))pg_printf(("      --no-locale           equivalent to --locale=C\n"
));
printf(_("      --pwfile=FILE         read password for the new superuser from file\n"))pg_printf(("      --pwfile=FILE         read password for the new superuser from file\n"
));
printf(_("  -T, --text-search-config=CFG\n"pg_printf(("  -T, --text-search-config=CFG\n" "                            default text search configuration\n"
))
	 "                            default text search configuration\n"))pg_printf(("  -T, --text-search-config=CFG\n" "                            default text search configuration\n"
));
printf(_("  -U, --username=NAME       database superuser name\n"))pg_printf(("  -U, --username=NAME       database superuser name\n"
));
printf(_("  -W, --pwprompt            prompt for a password for the new superuser\n"))pg_printf(("  -W, --pwprompt            prompt for a password for the new superuser\n"
));
printf(_("  -X, --waldir=WALDIR       location for the write-ahead log directory\n"))pg_printf(("  -X, --waldir=WALDIR       location for the write-ahead log directory\n"
));
printf(_("      --wal-segsize=SIZE    size of WAL segments, in megabytes\n"))pg_printf(("      --wal-segsize=SIZE    size of WAL segments, in megabytes\n"
));
printf(_("\nLess commonly used options:\n"))pg_printf(("\nLess commonly used options:\n"));
printf(_("  -d, --debug               generate lots of debugging output\n"))pg_printf(("  -d, --debug               generate lots of debugging output\n"
));
printf(_("      --discard-caches      set debug_discard_caches=1\n"))pg_printf(("      --discard-caches      set debug_discard_caches=1\n"
));
printf(_("  -L DIRECTORY              where to find the input files\n"))pg_printf(("  -L DIRECTORY              where to find the input files\n"
));
printf(_("  -n, --no-clean            do not clean up after errors\n"))pg_printf(("  -n, --no-clean            do not clean up after errors\n"
));
printf(_("  -N, --no-sync             do not wait for changes to be written safely to disk\n"))pg_printf(("  -N, --no-sync             do not wait for changes to be written safely to disk\n"
));
printf(_("      --no-instructions     do not print instructions for next steps\n"))pg_printf(("      --no-instructions     do not print instructions for next steps\n"
));
printf(_("  -s, --show                show internal settings\n"))pg_printf(("  -s, --show                show internal settings\n"
));
printf(_("  -S, --sync-only           only sync database files to disk, then exit\n"))pg_printf(("  -S, --sync-only           only sync database files to disk, then exit\n"
));
printf(_("\nOther options:\n"))pg_printf(("\nOther options:\n"));
printf(_("  -V, --version             output version information, then exit\n"))pg_printf(("  -V, --version             output version information, then exit\n"
));
printf(_("  -?, --help                show this help, then exit\n"))pg_printf(("  -?, --help                show this help, then exit\n"
));
printf(_("\nIf the data directory is not specified, the environment variable PGDATA\n"pg_printf(("\nIf the data directory is not specified, the environment variable PGDATA\n"
 "is used.\n"))
	 "is used.\n"))pg_printf(("\nIf the data directory is not specified, the environment variable PGDATA\n"
 "is used.\n"));
printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT)pg_printf(("\nReport bugs to <%s>.\n"), "pgsql-bugs@lists.postgresql.org"
);
printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL)pg_printf(("%s home page: <%s>\n"), "PostgreSQL", "https://www.postgresql.org/"
);
2223}

2225static void
2226check_authmethod_unspecified(const char **authmethod)
2227{
if (*authmethod == NULL((void*)0))
{
authwarning = true1;
*authmethod = "trust";
}
2233}

2235static void
2236check_authmethod_valid(const char *authmethod, const char *const *valid_methods, const char *conntype)
2237{
const char *const *p;

for (p = valid_methods; *p; p++)
{
if (strcmp(authmethod, *p) == 0)
	return;
/* with space = param */
if (strchr(authmethod, ' '))
	if (strncmp(authmethod, *p, (authmethod - strchr(authmethod, ' '))) == 0)
		return;
}

pg_log_error("invalid authentication method \"%s\" for \"%s\" connections",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "invalid authentication method \"%s\" for \"%s\" connections"
, authmethod, conntype); } while(0)
		 authmethod, conntype)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "invalid authentication method \"%s\" for \"%s\" connections"
, authmethod, conntype); } while(0);
exit(1);
2253}

2255static void
2256check_need_password(const char *authmethodlocal, const char *authmethodhost)
2257{
if ((strcmp(authmethodlocal, "md5") == 0 ||
 strcmp(authmethodlocal, "password") == 0 ||
 strcmp(authmethodlocal, "scram-sha-256") == 0) &&
(strcmp(authmethodhost, "md5") == 0 ||
 strcmp(authmethodhost, "password") == 0 ||
 strcmp(authmethodhost, "scram-sha-256") == 0) &&
!(pwprompt || pwfilename))
{
pg_log_error("must specify a password for the superuser to enable password authentication")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "must specify a password for the superuser to enable password authentication"
); } while(0);
exit(1);
}
2269}


2272void
2273setup_pgdata(void)
2274{
char	   *pgdata_get_env;

if (!pg_data)
{
pgdata_get_env = getenv("PGDATA");
if (pgdata_get_env && strlen(pgdata_get_env))
{
	/* PGDATA found */
	pg_data = pg_strdup(pgdata_get_env);
}
else
{
	pg_log_error("no data directory specified")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "no data directory specified"
); } while(0);
	fprintfpg_fprintf(stderrstderr,
			_("You must identify the directory where the data for this database system\n"("You must identify the directory where the data for this database system\n"
 "will reside.  Do this with either the invocation option -D or the\n"
 "environment variable PGDATA.\n")
			  "will reside.  Do this with either the invocation option -D or the\n"("You must identify the directory where the data for this database system\n"
 "will reside.  Do this with either the invocation option -D or the\n"
 "environment variable PGDATA.\n")
			  "environment variable PGDATA.\n")("You must identify the directory where the data for this database system\n"
 "will reside.  Do this with either the invocation option -D or the\n"
 "environment variable PGDATA.\n"));
	exit(1);
}
}

pgdata_native = pg_strdup(pg_data);
canonicalize_path(pg_data);

/*
* we have to set PGDATA for postgres rather than pass it on the command
* line to avoid dumb quoting problems on Windows, and we would especially
* need quotes otherwise on Windows because paths there are most likely to
* have embedded spaces.
*/
if (setenv("PGDATA", pg_data, 1) != 0)
{
pg_log_error("could not set environment")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not set environment"
); } while(0);
exit(1);
}
2310}


2313void
2314setup_bin_paths(const char *argv0)
2315{
int			ret;

if ((ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR"postgres (PostgreSQL) " "15devel" "\n",
					   backend_exec)) < 0)
{
char		full_path[MAXPGPATH1024];

if (find_my_exec(argv0, full_path) < 0)
	strlcpy(full_path, progname, sizeof(full_path));

if (ret == -1)
	pg_log_error("The program \"%s\" is needed by %s but was not found in the\n"do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" is needed by %s but was not found in the\n"
 "same directory as \"%s\".\n" "Check your installation.", "postgres"
, progname, full_path); } while(0)
				 "same directory as \"%s\".\n"do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" is needed by %s but was not found in the\n"
 "same directory as \"%s\".\n" "Check your installation.", "postgres"
, progname, full_path); } while(0)
				 "Check your installation.",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" is needed by %s but was not found in the\n"
 "same directory as \"%s\".\n" "Check your installation.", "postgres"
, progname, full_path); } while(0)
				 "postgres", progname, full_path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" is needed by %s but was not found in the\n"
 "same directory as \"%s\".\n" "Check your installation.", "postgres"
, progname, full_path); } while(0);
else
	pg_log_error("The program \"%s\" was found by \"%s\"\n"do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" was found by \"%s\"\n"
 "but was not the same version as %s.\n" "Check your installation."
, "postgres", full_path, progname); } while(0)
				 "but was not the same version as %s.\n"do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" was found by \"%s\"\n"
 "but was not the same version as %s.\n" "Check your installation."
, "postgres", full_path, progname); } while(0)
				 "Check your installation.",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" was found by \"%s\"\n"
 "but was not the same version as %s.\n" "Check your installation."
, "postgres", full_path, progname); } while(0)
				 "postgres", full_path, progname)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "The program \"%s\" was found by \"%s\"\n"
 "but was not the same version as %s.\n" "Check your installation."
, "postgres", full_path, progname); } while(0);
exit(1);
}

/* store binary directory */
strcpy(bin_path, backend_exec);
*last_dir_separator(bin_path) = '\0';
canonicalize_path(bin_path);

if (!share_path)
{
share_path = pg_malloc(MAXPGPATH1024);
get_share_path(backend_exec, share_path);
}
else if (!is_absolute_path(share_path)( (((share_path)[0]) == '/') ))
{
pg_log_error("input file location must be an absolute path")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "input file location must be an absolute path"
); } while(0);
exit(1);
}

canonicalize_path(share_path);
2356}

2358void
2359setup_locale_encoding(void)
2360{
setlocales();

if (strcmp(lc_ctype, lc_collate) == 0 &&
strcmp(lc_ctype, lc_time) == 0 &&
strcmp(lc_ctype, lc_numeric) == 0 &&
strcmp(lc_ctype, lc_monetary) == 0 &&
strcmp(lc_ctype, lc_messages) == 0)
printf(_("The database cluster will be initialized with locale \"%s\".\n"), lc_ctype)pg_printf(("The database cluster will be initialized with locale \"%s\".\n"
), lc_ctype);
else
{
printf(_("The database cluster will be initialized with locales\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  COLLATE:  %s\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  CTYPE:    %s\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  MESSAGES: %s\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  MONETARY: %s\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  NUMERIC:  %s\n"pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
		 "  TIME:     %s\n"),pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_collate,pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_ctype,pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_messages,pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_monetary,pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_numeric,pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time)
	   lc_time)pg_printf(("The database cluster will be initialized with locales\n"
 "  COLLATE:  %s\n" "  CTYPE:    %s\n" "  MESSAGES: %s\n" "  MONETARY: %s\n"
 "  NUMERIC:  %s\n" "  TIME:     %s\n"), lc_collate, lc_ctype
, lc_messages, lc_monetary, lc_numeric, lc_time);
}

if (!encoding)
{
int			ctype_enc;

ctype_enc = pg_get_encoding_from_locale(lc_ctype, true1);

if (ctype_enc == -1)
{
	/* Couldn't recognize the locale's codeset */
	pg_log_error("could not find suitable encoding for locale \"%s\"",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not find suitable encoding for locale \"%s\""
, lc_ctype); } while(0)
				 lc_ctype)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not find suitable encoding for locale \"%s\""
, lc_ctype); } while(0);
	fprintfpg_fprintf(stderrstderr, _("Rerun %s with the -E option.\n")("Rerun %s with the -E option.\n"), progname);
	fprintfpg_fprintf(stderrstderr, _("Try \"%s --help\" for more information.\n")("Try \"%s --help\" for more information.\n"),
			progname);
	exit(1);
}
else if (!pg_valid_server_encoding_id(ctype_enc))
{
	/*
	 * We recognized it, but it's not a legal server encoding. On
	 * Windows, UTF-8 works with any locale, so we can fall back to
	 * UTF-8.
	 */
2409#ifdef WIN32
	encodingid = PG_UTF8;
	printf(_("Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n"pg_printf(("Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n"
 "The default database encoding will be set to \"%s\" instead.\n"
), pg_encoding_to_char(ctype_enc), pg_encoding_to_char(encodingid
))
			 "The default database encoding will be set to \"%s\" instead.\n"),pg_printf(("Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n"
 "The default database encoding will be set to \"%s\" instead.\n"
), pg_encoding_to_char(ctype_enc), pg_encoding_to_char(encodingid
))
		   pg_encoding_to_char(ctype_enc),pg_printf(("Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n"
 "The default database encoding will be set to \"%s\" instead.\n"
), pg_encoding_to_char(ctype_enc), pg_encoding_to_char(encodingid
))
		   pg_encoding_to_char(encodingid))pg_printf(("Encoding \"%s\" implied by locale is not allowed as a server-side encoding.\n"
 "The default database encoding will be set to \"%s\" instead.\n"
), pg_encoding_to_char(ctype_enc), pg_encoding_to_char(encodingid
));
2415#else
	pg_log_error("locale \"%s\" requires unsupported encoding \"%s\"",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "locale \"%s\" requires unsupported encoding \"%s\""
, lc_ctype, pg_encoding_to_char(ctype_enc)); } while(0)
				 lc_ctype, pg_encoding_to_char(ctype_enc))do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "locale \"%s\" requires unsupported encoding \"%s\""
, lc_ctype, pg_encoding_to_char(ctype_enc)); } while(0);
	fprintfpg_fprintf(stderrstderr,
			_("Encoding \"%s\" is not allowed as a server-side encoding.\n"("Encoding \"%s\" is not allowed as a server-side encoding.\n"
 "Rerun %s with a different locale selection.\n")
			  "Rerun %s with a different locale selection.\n")("Encoding \"%s\" is not allowed as a server-side encoding.\n"
 "Rerun %s with a different locale selection.\n"),
			pg_encoding_to_char(ctype_enc), progname);
	exit(1);
2423#endif
}
else
{
	encodingid = ctype_enc;
	printf(_("The default database encoding has accordingly been set to \"%s\".\n"),pg_printf(("The default database encoding has accordingly been set to \"%s\".\n"
), pg_encoding_to_char(encodingid))
		   pg_encoding_to_char(encodingid))pg_printf(("The default database encoding has accordingly been set to \"%s\".\n"
), pg_encoding_to_char(encodingid));
}
}
else
encodingid = get_encoding_id(encoding);

if (!check_locale_encoding(lc_ctype, encodingid) ||
!check_locale_encoding(lc_collate, encodingid))
exit(1);				/* check_locale_encoding printed the error */

2439}


2442void
2443setup_data_file_paths(void)
2444{
set_input(&bki_file, "postgres.bki");
set_input(&hba_file, "pg_hba.conf.sample");
set_input(&ident_file, "pg_ident.conf.sample");
set_input(&conf_file, "postgresql.conf.sample");
set_input(&dictionary_file, "snowball_create.sql");
set_input(&info_schema_file, "information_schema.sql");
set_input(&features_file, "sql_features.txt");
set_input(&system_constraints_file, "system_constraints.sql");
set_input(&system_functions_file, "system_functions.sql");
set_input(&system_views_file, "system_views.sql");

if (show_setting || debug)
{
fprintfpg_fprintf(stderrstderr,
		"VERSION=%s\n"
		"PGDATA=%s\nshare_path=%s\nPGPATH=%s\n"
		"POSTGRES_SUPERUSERNAME=%s\nPOSTGRES_BKI=%s\n"
		"POSTGRESQL_CONF_SAMPLE=%s\n"
		"PG_HBA_SAMPLE=%s\nPG_IDENT_SAMPLE=%s\n",
		PG_VERSION"15devel",
		pg_data, share_path, bin_path,
		username, bki_file,
		conf_file,
		hba_file, ident_file);
if (show_setting)
	exit(0);
}

check_input(bki_file);
check_input(hba_file);
check_input(ident_file);
check_input(conf_file);
check_input(dictionary_file);
check_input(info_schema_file);
check_input(features_file);
check_input(system_constraints_file);
check_input(system_functions_file);
check_input(system_views_file);
2483}


2486void
2487setup_text_search(void)
2488{
if (!default_text_search_config)
{
default_text_search_config = find_matching_ts_config(lc_ctype);
if (!default_text_search_config)
{
	pg_log_info("could not find suitable text search configuration for locale \"%s\"",do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "could not find suitable text search configuration for locale \"%s\""
, lc_ctype); } while(0)
				lc_ctype)do { if (__builtin_expect((__pg_log_level <= PG_LOG_INFO) !=
 0, 1)) pg_log_generic(PG_LOG_INFO, "could not find suitable text search configuration for locale \"%s\""
, lc_ctype); } while(0);
	default_text_search_config = "simple";
}
}
else
{
const char *checkmatch = find_matching_ts_config(lc_ctype);

if (checkmatch == NULL((void*)0))
{
	pg_log_warning("suitable text search configuration for locale \"%s\" is unknown",do { if (__builtin_expect((__pg_log_level <= PG_LOG_WARNING
) != 0, 1)) pg_log_generic(PG_LOG_WARNING, "suitable text search configuration for locale \"%s\" is unknown"
, lc_ctype); } while(0)
				   lc_ctype)do { if (__builtin_expect((__pg_log_level <= PG_LOG_WARNING
) != 0, 1)) pg_log_generic(PG_LOG_WARNING, "suitable text search configuration for locale \"%s\" is unknown"
, lc_ctype); } while(0);
}
else if (strcmp(checkmatch, default_text_search_config) != 0)
{
	pg_log_warning("specified text search configuration \"%s\" might not match locale \"%s\"",do { if (__builtin_expect((__pg_log_level <= PG_LOG_WARNING
) != 0, 1)) pg_log_generic(PG_LOG_WARNING, "specified text search configuration \"%s\" might not match locale \"%s\""
, default_text_search_config, lc_ctype); } while(0)
				   default_text_search_config, lc_ctype)do { if (__builtin_expect((__pg_log_level <= PG_LOG_WARNING
) != 0, 1)) pg_log_generic(PG_LOG_WARNING, "specified text search configuration \"%s\" might not match locale \"%s\""
, default_text_search_config, lc_ctype); } while(0);
}
}

printf(_("The default text search configuration will be set to \"%s\".\n"),pg_printf(("The default text search configuration will be set to \"%s\".\n"
), default_text_search_config)
   default_text_search_config)pg_printf(("The default text search configuration will be set to \"%s\".\n"
), default_text_search_config);

2518}


2521void
2522setup_signals(void)
2523{
/* some of these are not valid on Windows */
2525#ifdef SIGHUP1
pqsignal(SIGHUP1, trapsig);
2527#endif
2528#ifdef SIGINT2
pqsignal(SIGINT2, trapsig);
2530#endif
2531#ifdef SIGQUIT3
pqsignal(SIGQUIT3, trapsig);
2533#endif
2534#ifdef SIGTERM15
pqsignal(SIGTERM15, trapsig);
2536#endif

/* Ignore SIGPIPE when writing to backend, so we can clean up */
2539#ifdef SIGPIPE13
pqsignal(SIGPIPE13, SIG_IGN((__sighandler_t) 1));
2541#endif

/* Prevent SIGSYS so we can probe for kernel calls that might not work */
2544#ifdef SIGSYS31
pqsignal(SIGSYS31, SIG_IGN((__sighandler_t) 1));
2546#endif
2547}


2550void
2551create_data_directory(void)
2552{
int			ret;

switch ((ret = pg_check_dir(pg_data)))
{
case 0:
	/* PGDATA not there, must create it */
	printf(_("creating directory %s ... "),pg_printf(("creating directory %s ... "), pg_data)
		   pg_data)pg_printf(("creating directory %s ... "), pg_data);
	fflush(stdoutstdout);

	if (pg_mkdir_p(pg_data, pg_dir_create_mode) != 0)
	{
		pg_log_error("could not create directory \"%s\": %m", pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, pg_data); } while(0);
		exit(1);
	}
	else
		check_ok();

	made_new_pgdata = true1;
	break;

case 1:
	/* Present but empty, fix permissions and use it */
	printf(_("fixing permissions on existing directory %s ... "),pg_printf(("fixing permissions on existing directory %s ... "
), pg_data)
		   pg_data)pg_printf(("fixing permissions on existing directory %s ... "
), pg_data);
	fflush(stdoutstdout);

	if (chmod(pg_data, pg_dir_create_mode) != 0)
	{
		pg_log_error("could not change permissions of directory \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of directory \"%s\": %m"
, pg_data); } while(0)
					 pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of directory \"%s\": %m"
, pg_data); } while(0);
		exit(1);
	}
	else
		check_ok();

	found_existing_pgdata = true1;
	break;

case 2:
case 3:
case 4:
	/* Present and not empty */
	pg_log_error("directory \"%s\" exists but is not empty", pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "directory \"%s\" exists but is not empty"
, pg_data); } while(0);
	if (ret != 4)
		warn_on_mount_point(ret);
	else
		fprintfpg_fprintf(stderrstderr,
				_("If you want to create a new database system, either remove or empty\n"("If you want to create a new database system, either remove or empty\n"
 "the directory \"%s\" or run %s\n" "with an argument other than \"%s\".\n"
)
				  "the directory \"%s\" or run %s\n"("If you want to create a new database system, either remove or empty\n"
 "the directory \"%s\" or run %s\n" "with an argument other than \"%s\".\n"
)
				  "with an argument other than \"%s\".\n")("If you want to create a new database system, either remove or empty\n"
 "the directory \"%s\" or run %s\n" "with an argument other than \"%s\".\n"
),
				pg_data, progname, pg_data);
	exit(1);			/* no further message needed */

default:
	/* Trouble accessing directory */
	pg_log_error("could not access directory \"%s\": %m", pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not access directory \"%s\": %m"
, pg_data); } while(0);
	exit(1);
}
2612}


2615/* Create WAL directory, and symlink if required */
2616void
2617create_xlog_or_symlink(void)
2618{
char	   *subdirloc;

/* form name of the place for the subdirectory or symlink */
subdirloc = psprintf("%s/pg_wal", pg_data);

if (xlog_dir)
{
int			ret;

/* clean up xlog directory name, check it's absolute */
canonicalize_path(xlog_dir);
if (!is_absolute_path(xlog_dir)( (((xlog_dir)[0]) == '/') ))
{
	pg_log_error("WAL directory location must be an absolute path")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "WAL directory location must be an absolute path"
); } while(0);
	exit(1);
}

/* check if the specified xlog directory exists/is empty */
switch ((ret = pg_check_dir(xlog_dir)))
{
	case 0:
		/* xlog directory not there, must create it */
		printf(_("creating directory %s ... "),pg_printf(("creating directory %s ... "), xlog_dir)
			   xlog_dir)pg_printf(("creating directory %s ... "), xlog_dir);
		fflush(stdoutstdout);

		if (pg_mkdir_p(xlog_dir, pg_dir_create_mode) != 0)
		{
			pg_log_error("could not create directory \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, xlog_dir); } while(0)
						 xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, xlog_dir); } while(0);
			exit(1);
		}
		else
			check_ok();

		made_new_xlogdir = true1;
		break;

	case 1:
		/* Present but empty, fix permissions and use it */
		printf(_("fixing permissions on existing directory %s ... "),pg_printf(("fixing permissions on existing directory %s ... "
), xlog_dir)
			   xlog_dir)pg_printf(("fixing permissions on existing directory %s ... "
), xlog_dir);
		fflush(stdoutstdout);

		if (chmod(xlog_dir, pg_dir_create_mode) != 0)
		{
			pg_log_error("could not change permissions of directory \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of directory \"%s\": %m"
, xlog_dir); } while(0)
						 xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not change permissions of directory \"%s\": %m"
, xlog_dir); } while(0);
			exit(1);
		}
		else
			check_ok();

		found_existing_xlogdir = true1;
		break;

	case 2:
	case 3:
	case 4:
		/* Present and not empty */
		pg_log_error("directory \"%s\" exists but is not empty", xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "directory \"%s\" exists but is not empty"
, xlog_dir); } while(0);
		if (ret != 4)
			warn_on_mount_point(ret);
		else
			fprintfpg_fprintf(stderrstderr,
					_("If you want to store the WAL there, either remove or empty the directory\n"("If you want to store the WAL there, either remove or empty the directory\n"
 "\"%s\".\n")
					  "\"%s\".\n")("If you want to store the WAL there, either remove or empty the directory\n"
 "\"%s\".\n"),
					xlog_dir);
		exit(1);

	default:
		/* Trouble accessing directory */
		pg_log_error("could not access directory \"%s\": %m", xlog_dir)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not access directory \"%s\": %m"
, xlog_dir); } while(0);
		exit(1);
}

2695#ifdef HAVE_SYMLINK1
if (symlink(xlog_dir, subdirloc) != 0)
{
	pg_log_error("could not create symbolic link \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create symbolic link \"%s\": %m"
, subdirloc); } while(0)
				 subdirloc)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create symbolic link \"%s\": %m"
, subdirloc); } while(0);
	exit(1);
}
2702#else
pg_log_error("symlinks are not supported on this platform")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "symlinks are not supported on this platform"
); } while(0);
exit(1);
2705#endif
}
else
{
/* Without -X option, just make the subdirectory normally */
if (mkdir(subdirloc, pg_dir_create_mode) < 0)
{
	pg_log_error("could not create directory \"%s\": %m",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, subdirloc); } while(0)
				 subdirloc)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, subdirloc); } while(0);
	exit(1);
}
}

free(subdirloc);
2719}


2722void
2723warn_on_mount_point(int error)
2724{
if (error == 2)
fprintfpg_fprintf(stderrstderr,
		_("It contains a dot-prefixed/invisible file, perhaps due to it being a mount point.\n")("It contains a dot-prefixed/invisible file, perhaps due to it being a mount point.\n"
));
else if (error == 3)
fprintfpg_fprintf(stderrstderr,
		_("It contains a lost+found directory, perhaps due to it being a mount point.\n")("It contains a lost+found directory, perhaps due to it being a mount point.\n"
));

fprintfpg_fprintf(stderrstderr,
	_("Using a mount point directly as the data directory is not recommended.\n"("Using a mount point directly as the data directory is not recommended.\n"
 "Create a subdirectory under the mount point.\n")
	  "Create a subdirectory under the mount point.\n")("Using a mount point directly as the data directory is not recommended.\n"
 "Create a subdirectory under the mount point.\n"));
2735}


2738void
2739initialize_data_directory(void)
2740{
PG_CMD_DECLchar cmd[1024]; FILE *cmdfd;
int			i;

setup_signals();

/*
* Set mask based on requested PGDATA permissions.  pg_mode_mask, and
* friends like pg_dir_create_mode, are set to owner-only by default and
* then updated if -g is passed in by calling SetDataDirectoryCreatePerm()
* when parsing our options (see above).
*/
umask(pg_mode_mask);

create_data_directory();

create_xlog_or_symlink();

/* Create required subdirectories (other than pg_wal) */
printf(_("creating subdirectories ... "))pg_printf(("creating subdirectories ... "));
fflush(stdoutstdout);

for (i = 0; i < lengthof(subdirs)(sizeof (subdirs) / sizeof ((subdirs)[0])); i++)
{
char	   *path;

path = psprintf("%s/%s", pg_data, subdirs[i]);

/*
 * The parent directory already exists, so we only need mkdir() not
 * pg_mkdir_p() here, which avoids some failure modes; cf bug #13853.
 */
if (mkdir(path, pg_dir_create_mode) < 0)
{
	pg_log_error("could not create directory \"%s\": %m", path)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not create directory \"%s\": %m"
, path); } while(0);
	exit(1);
}

free(path);
}

check_ok();

/* Top level PG_VERSION is checked by bootstrapper, so make it first */
write_version_file(NULL((void*)0));

/* Select suitable configuration settings */
set_null_conf();
test_config_settings();

/* Now create all the text config files */
setup_config();

/* Bootstrap template1 */
bootstrap_template1();

/*
* Make the per-database PG_VERSION for template1 only after init'ing it
*/
write_version_file("base/1");

/*
* Create the stuff we don't need to use bootstrap mode for, using a
* backend running in simple standalone mode.
*/
fputs(_("performing post-bootstrap initialization ... ")("performing post-bootstrap initialization ... "), stdoutstdout);
fflush(stdoutstdout);

snprintfpg_snprintf(cmd, sizeof(cmd),
	 "\"%s\" %s %s template1 >%s",
	 backend_exec, backend_options, extra_options,
	 DEVNULL"/dev/null");

PG_CMD_OPENdo { cmdfd = popen_check(cmd, "w"); if (cmdfd == ((void*)0)) exit
(1); } while (0);

setup_auth(cmdfd);

setup_run_file(cmdfd, system_constraints_file);

setup_run_file(cmdfd, system_functions_file);

setup_depend(cmdfd);

/*
* Note that no objects created after setup_depend() will be "pinned".
* They are all droppable at the whim of the DBA.
*/

setup_run_file(cmdfd, system_views_file);

setup_description(cmdfd);

setup_collation(cmdfd);

setup_run_file(cmdfd, dictionary_file);

setup_privileges(cmdfd);

setup_schema(cmdfd);

load_plpgsql(cmdfd);

vacuum_db(cmdfd);

make_template0(cmdfd);

make_postgres(cmdfd);

PG_CMD_CLOSEdo { if (pclose_check(cmdfd)) exit(1); } while (0);

check_ok();
2851}


2854int
2855main(int argc, char *argv[])
2856{
static struct option long_options[] = {
{"pgdata", required_argument1, NULL((void*)0), 'D'},
{"encoding", required_argument1, NULL((void*)0), 'E'},
{"locale", required_argument1, NULL((void*)0), 1},
{"lc-collate", required_argument1, NULL((void*)0), 2},
{"lc-ctype", required_argument1, NULL((void*)0), 3},
{"lc-monetary", required_argument1, NULL((void*)0), 4},
{"lc-numeric", required_argument1, NULL((void*)0), 5},
{"lc-time", required_argument1, NULL((void*)0), 6},
{"lc-messages", required_argument1, NULL((void*)0), 7},
{"no-locale", no_argument0, NULL((void*)0), 8},
{"text-search-config", required_argument1, NULL((void*)0), 'T'},
{"auth", required_argument1, NULL((void*)0), 'A'},
{"auth-local", required_argument1, NULL((void*)0), 10},
{"auth-host", required_argument1, NULL((void*)0), 11},
{"pwprompt", no_argument0, NULL((void*)0), 'W'},
{"pwfile", required_argument1, NULL((void*)0), 9},
{"username", required_argument1, NULL((void*)0), 'U'},
{"help", no_argument0, NULL((void*)0), '?'},
{"version", no_argument0, NULL((void*)0), 'V'},
{"debug", no_argument0, NULL((void*)0), 'd'},
{"show", no_argument0, NULL((void*)0), 's'},
{"noclean", no_argument0, NULL((void*)0), 'n'},	/* for backwards compatibility */
{"no-clean", no_argument0, NULL((void*)0), 'n'},
{"nosync", no_argument0, NULL((void*)0), 'N'}, /* for backwards compatibility */
{"no-sync", no_argument0, NULL((void*)0), 'N'},
{"no-instructions", no_argument0, NULL((void*)0), 13},
{"sync-only", no_argument0, NULL((void*)0), 'S'},
{"waldir", required_argument1, NULL((void*)0), 'X'},
{"wal-segsize", required_argument1, NULL((void*)0), 12},
{"data-checksums", no_argument0, NULL((void*)0), 'k'},
{"allow-group-access", no_argument0, NULL((void*)0), 'g'},
{"discard-caches", no_argument0, NULL((void*)0), 14},
{NULL((void*)0), 0, NULL((void*)0), 0}
};

/*
* options with no short version return a low integer, the rest return
* their short version value
*/
int			c;
int			option_index;
char	   *effective_user;
PQExpBuffer start_db_cmd;
char		pg_ctl_path[MAXPGPATH1024];

/*
* Ensure that buffering behavior of stdout matches what it is in
* interactive usage (at least on most platforms).  This prevents
* unexpected output ordering when, eg, output is redirected to a file.
* POSIX says we must do this before any other usage of these files.
*/
setvbuf(stdoutstdout, NULL((void*)0), PG_IOLBF1, 0);

pg_logging_init(argv[0]);
progname = get_progname(argv[0]);
set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("initdb")("initdb" "-" "15"));

if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
{
	usage(progname);
	exit(0);
}
if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
{
	puts("initdb (PostgreSQL) " PG_VERSION"15devel");
	exit(0);
}
}

/* process command-line options */

while ((c = getopt_long(argc, argv, "A:dD:E:gkL:nNsST:U:WX:", long_options, &option_index)) != -1)
{
switch (c)
{
	case 'A':
		authmethodlocal = authmethodhost = pg_strdup(optarg);

		/*
		 * When ident is specified, use peer for local connections.
		 * Mirrored, when peer is specified, use ident for TCP/IP
		 * connections.
		 */
		if (strcmp(authmethodhost, "ident") == 0)
			authmethodlocal = "peer";
		else if (strcmp(authmethodlocal, "peer") == 0)
			authmethodhost = "ident";
		break;
	case 10:
		authmethodlocal = pg_strdup(optarg);
		break;
	case 11:
		authmethodhost = pg_strdup(optarg);
		break;
	case 'D':
		pg_data = pg_strdup(optarg);
		break;
	case 'E':
		encoding = pg_strdup(optarg);
		break;
	case 'W':
		pwprompt = true1;
		break;
	case 'U':
		username = pg_strdup(optarg);
		break;
	case 'd':
		debug = true1;
		printf(_("Running in debug mode.\n"))pg_printf(("Running in debug mode.\n"));
		break;
	case 'n':
		noclean = true1;
		printf(_("Running in no-clean mode.  Mistakes will not be cleaned up.\n"))pg_printf(("Running in no-clean mode.  Mistakes will not be cleaned up.\n"
));
		break;
	case 'N':
		do_sync = false0;
		break;
	case 'S':
		sync_only = true1;
		break;
	case 'k':
		data_checksums = true1;
		break;
	case 'L':
		share_path = pg_strdup(optarg);
		break;
	case 1:
		locale = pg_strdup(optarg);
		break;
	case 2:
		lc_collate = pg_strdup(optarg);
		break;
	case 3:
		lc_ctype = pg_strdup(optarg);
		break;
	case 4:
		lc_monetary = pg_strdup(optarg);
		break;
	case 5:
		lc_numeric = pg_strdup(optarg);
		break;
	case 6:
		lc_time = pg_strdup(optarg);
		break;
	case 7:
		lc_messages = pg_strdup(optarg);
		break;
	case 8:
		locale = "C";
		break;
	case 9:
		pwfilename = pg_strdup(optarg);
		break;
	case 's':
		show_setting = true1;
		break;
	case 'T':
		default_text_search_config = pg_strdup(optarg);
		break;
	case 'X':
		xlog_dir = pg_strdup(optarg);
		break;
	case 12:
		str_wal_segment_size_mb = pg_strdup(optarg);
		break;
	case 13:
		noinstructions = true1;
		break;
	case 'g':
		SetDataDirectoryCreatePerm(PG_DIR_MODE_GROUP((0400|0200|0100) | (0400 >> 3) | (0100 >> 3)));
		break;
	case 14:
		extra_options = psprintf("%s %s",
								 extra_options,
								 "-c debug_discard_caches=1");
		break;
	default:
		/* getopt_long already emitted a complaint */
		fprintfpg_fprintf(stderrstderr, _("Try \"%s --help\" for more information.\n")("Try \"%s --help\" for more information.\n"),
				progname);
		exit(1);
}
}


/*
* Non-option argument specifies data directory as long as it wasn't
* already specified with -D / --pgdata
*/
if (optind < argc && !pg_data)
{
pg_data = pg_strdup(argv[optind]);
optind++;
}

if (optind < argc)
{
pg_log_error("too many command-line arguments (first is \"%s\")",do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "too many command-line arguments (first is \"%s\")"
, argv[optind]); } while(0)
			 argv[optind])do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "too many command-line arguments (first is \"%s\")"
, argv[optind]); } while(0);
fprintfpg_fprintf(stderrstderr, _("Try \"%s --help\" for more information.\n")("Try \"%s --help\" for more information.\n"),
		progname);
exit(1);
}

atexit(cleanup_directories_atexit);

/* If we only need to fsync, just do it and exit */
if (sync_only)
{
setup_pgdata();

/* must check that directory is readable */
if (pg_check_dir(pg_data) <= 0)
{
	pg_log_error("could not access directory \"%s\": %m", pg_data)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "could not access directory \"%s\": %m"
, pg_data); } while(0);
	exit(1);
}

fputs(_("syncing data to disk ... ")("syncing data to disk ... "), stdoutstdout);
fflush(stdoutstdout);
fsync_pgdata(pg_data, PG_VERSION_NUM150000);
check_ok();
return 0;
}

if (pwprompt && pwfilename)
{
pg_log_error("password prompt and password file cannot be specified together")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "password prompt and password file cannot be specified together"
); } while(0);
exit(1);
}

check_authmethod_unspecified(&authmethodlocal);
check_authmethod_unspecified(&authmethodhost);

check_authmethod_valid(authmethodlocal, auth_methods_local, "local");
check_authmethod_valid(authmethodhost, auth_methods_host, "host");

check_need_password(authmethodlocal, authmethodhost);

/* set wal segment size */
if (str_wal_segment_size_mb == NULL((void*)0))
wal_segment_size_mb = (DEFAULT_XLOG_SEG_SIZE(16*1024*1024)) / (1024 * 1024);
else
{
char	   *endptr;

/* check that the argument is a number */
wal_segment_size_mb = strtol(str_wal_segment_size_mb, &endptr, 10);

/* verify that wal segment size is valid */
if (endptr == str_wal_segment_size_mb || *endptr != '\0')
{
	pg_log_error("argument of --wal-segsize must be a number")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "argument of --wal-segsize must be a number"
); } while(0);
	exit(1);
}
if (!IsValidWalSegSize(wal_segment_size_mb * 1024 * 1024)((wal_segment_size_mb * 1024 * 1024 > 0 && ((wal_segment_size_mb
 * 1024 * 1024) & ((wal_segment_size_mb * 1024 * 1024)-1)
) == 0) && ((wal_segment_size_mb * 1024 * 1024) >=
* 1024 && (wal_segment_size_mb * 1024 * 1024) <=
* 1024 * 1024)))
{
	pg_log_error("argument of --wal-segsize must be a power of 2 between 1 and 1024")do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "argument of --wal-segsize must be a power of 2 between 1 and 1024"
); } while(0);
	exit(1);
}
}

get_restricted_token();

setup_pgdata();

setup_bin_paths(argv[0]);

effective_user = get_id();
if (!username)
username = effective_user;

if (strncmp(username, "pg_", 3) == 0)
{
pg_log_error("superuser name \"%s\" is disallowed; role names cannot begin with \"pg_\"", username)do { if (__builtin_expect((__pg_log_level <= PG_LOG_ERROR)
 != 0, 1)) pg_log_generic(PG_LOG_ERROR, "superuser name \"%s\" is disallowed; role names cannot begin with \"pg_\""
, username); } while(0);
exit(1);
}

printf(_("The files belonging to this database system will be owned "pg_printf(("The files belonging to this database system will be owned "
 "by user \"%s\".\n" "This user must also own the server process.\n\n"
), effective_user)
	 "by user \"%s\".\n"pg_printf(("The files belonging to this database system will be owned "
 "by user \"%s\".\n" "This user must also own the server process.\n\n"
), effective_user)
	 "This user must also own the server process.\n\n"),pg_printf(("The files belonging to this database system will be owned "
 "by user \"%s\".\n" "This user must also own the server process.\n\n"
), effective_user)
   effective_user)pg_printf(("The files belonging to this database system will be owned "
 "by user \"%s\".\n" "This user must also own the server process.\n\n"
), effective_user);

set_info_version();

setup_data_file_paths();

setup_locale_encoding();

setup_text_search();

printf("\n")pg_printf("\n");

if (data_checksums)
printf(_("Data page checksums are enabled.\n"))pg_printf(("Data page checksums are enabled.\n"));
else
printf(_("Data page checksums are disabled.\n"))pg_printf(("Data page checksums are disabled.\n"));

if (pwprompt || pwfilename)
get_su_pwd();

printf("\n")pg_printf("\n");

initialize_data_directory();

if (do_sync)
{
fputs(_("syncing data to disk ... ")("syncing data to disk ... "), stdoutstdout);
fflush(stdoutstdout);
fsync_pgdata(pg_data, PG_VERSION_NUM150000);
check_ok();
}
else
printf(_("\nSync to disk skipped.\nThe data directory might become corrupt if the operating system crashes.\n"))pg_printf(("\nSync to disk skipped.\nThe data directory might become corrupt if the operating system crashes.\n"
));

if (authwarning)
{
printf("\n")pg_printf("\n");
pg_log_warning("enabling \"trust\" authentication for local connections")do { if (__builtin_expect((__pg_log_level <= PG_LOG_WARNING
) != 0, 1)) pg_log_generic(PG_LOG_WARNING, "enabling \"trust\" authentication for local connections"
); } while(0);
fprintfpg_fprintf(stderrstderr, _("You can change this by editing pg_hba.conf or using the option -A, or\n"("You can change this by editing pg_hba.conf or using the option -A, or\n"
 "--auth-local and --auth-host, the next time you run initdb.\n"
)
				  "--auth-local and --auth-host, the next time you run initdb.\n")("You can change this by editing pg_hba.conf or using the option -A, or\n"
 "--auth-local and --auth-host, the next time you run initdb.\n"
));
}

if (!noinstructions)
{
/*
 * Build up a shell command to tell the user how to start the server
 */
start_db_cmd = createPQExpBuffer();

/* Get directory specification used to start initdb ... */
strlcpy(pg_ctl_path, argv[0], sizeof(pg_ctl_path));
canonicalize_path(pg_ctl_path);
get_parent_directory(pg_ctl_path);
/* ... and tag on pg_ctl instead */
join_path_components(pg_ctl_path, pg_ctl_path, "pg_ctl");

/* Convert the path to use native separators */
make_native_path(pg_ctl_path);

/* path to pg_ctl, properly quoted */
appendShellString(start_db_cmd, pg_ctl_path);

/* add -D switch, with properly quoted data directory */
appendPQExpBufferStr(start_db_cmd, " -D ");
appendShellString(start_db_cmd, pgdata_native);

/* add suggested -l switch and "start" command */
/* translator: This is a placeholder in a shell command. */
appendPQExpBuffer(start_db_cmd, " -l %s start", _("logfile")("logfile"));

printf(_("\nSuccess. You can now start the database server using:\n\n"pg_printf(("\nSuccess. You can now start the database server using:\n\n"
 "    %s\n\n"), start_db_cmd->data)
		 "    %s\n\n"),pg_printf(("\nSuccess. You can now start the database server using:\n\n"
 "    %s\n\n"), start_db_cmd->data)
	   start_db_cmd->data)pg_printf(("\nSuccess. You can now start the database server using:\n\n"
 "    %s\n\n"), start_db_cmd->data);

destroyPQExpBuffer(start_db_cmd);
}


success = true1;
return 0;
3221}