?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Disallow empty passwords in LDAP authentication, the same way
[PostgreSQL.git] / src / bin / initdb / initdb.c
blobe7eeca473bb0f989101cec55b8c0c142d1e972b2
1 /*-------------------------------------------------------------------------
2 *
3 * initdb --- initialize a PostgreSQL installation
4 *
5 * initdb creates (initializes) a PostgreSQL database cluster (site,
6 * instance, installation, whatever). A database cluster is a
7 * collection of PostgreSQL databases all managed by the same server.
8 *
9 * To create the database cluster, we create the directory that contains
10 * all its data, create the files that hold the global tables, create
11 * a few other control files for it, and create three databases: the
12 * template databases "template0" and "template1", and a default user
13 * database "postgres".
14 *
15 * The template databases are ordinary PostgreSQL databases. template0
16 * is never supposed to change after initdb, whereas template1 can be
17 * changed to add site-local standard data. Either one can be copied
18 * to produce a new database.
19 *
20 * For largely-historical reasons, the template1 database is the one built
21 * by the basic bootstrap process. After it is complete, template0 and
22 * the default database, postgres, are made just by copying template1.
23 *
24 * To create template1, we run the postgres (backend) program in bootstrap
25 * mode and feed it data from the postgres.bki library file. After this
26 * initial bootstrap phase, some additional stuff is created by normal
27 * SQL commands fed to a standalone backend. Some of those commands are
28 * just embedded into this program (yeah, it's ugly), but larger chunks
29 * are taken from script files.
30 *
31 *
32 * Note:
33 * The program has some memory leakage - it isn't worth cleaning it up.
34 *
35 * This is a C implementation of the previous shell script for setting up a
36 * PostgreSQL cluster location, and should be highly compatible with it.
37 * author of C translation: Andrew Dunstan mailto:andrew@dunslane.net
38 *
39 * This code is released under the terms of the PostgreSQL License.
40 *
41 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
42 * Portions Copyright (c) 1994, Regents of the University of California
43 * Portions taken from FreeBSD.
44 *
45 * $PostgreSQL$
46 *
47 *-------------------------------------------------------------------------
48 */
49
50 #include "postgres_fe.h"
51
52 #include <dirent.h>
53 #include <sys/stat.h>
54 #include <unistd.h>
55 #include <locale.h>
56 #include <signal.h>
57 #include <time.h>
58
59 #include "libpq/pqsignal.h"
60 #include "mb/pg_wchar.h"
61 #include "getaddrinfo.h"
62 #include "getopt_long.h"
63 #include "miscadmin.h"
64
65
66 /*
67 * these values are passed in by makefile defines
68 */
69 static char *share_path = NULL;
70
71 /* values to be obtained from arguments */
72 static char *pg_data = "";
73 static char *encoding = "";
74 static char *locale = "";
75 static char *lc_collate = "";
76 static char *lc_ctype = "";
77 static char *lc_monetary = "";
78 static char *lc_numeric = "";
79 static char *lc_time = "";
80 static char *lc_messages = "";
81 static const char *default_text_search_config = "";
82 static char *username = "";
83 static bool pwprompt = false;
84 static char *pwfilename = NULL;
85 static char *authmethod = "";
86 static bool debug = false;
87 static bool noclean = false;
88 static bool show_setting = false;
89 static char *xlog_dir = "";
90
91
92 /* internal vars */
93 static const char *progname;
94 static char *encodingid = "0";
95 static char *bki_file;
96 static char *desc_file;
97 static char *shdesc_file;
98 static char *hba_file;
99 static char *ident_file;
100 static char *conf_file;
101 static char *conversion_file;
102 static char *dictionary_file;
103 static char *info_schema_file;
104 static char *features_file;
105 static char *system_views_file;
106 static bool made_new_pgdata = false;
107 static bool found_existing_pgdata = false;
108 static bool made_new_xlogdir = false;
109 static bool found_existing_xlogdir = false;
110 static char infoversion[100];
111 static bool caught_signal = false;
112 static bool output_failed = false;
113 static int output_errno = 0;
114
115 /* defaults */
116 static int n_connections = 10;
117 static int n_buffers = 50;
118
119 /*
120 * Warning messages for authentication methods
121 */
122 #define AUTHTRUST_WARNING \
123 "# CAUTION: Configuring the system for local \"trust\" authentication allows\n" \
124 "# any local user to connect as any PostgreSQL user, including the database\n" \
125 "# superuser. If you do not trust all your local users, use another\n" \
126 "# authentication method.\n"
127 static char *authwarning = NULL;
128
129 /*
130 * Centralized knowledge of switches to pass to backend
131 *
132 * Note: in the shell-script version, we also passed PGDATA as a -D switch,
133 * but here it is more convenient to pass it as an environment variable
134 * (no quoting to worry about).
135 */
136 static const char *boot_options = "-F";
137 static const char *backend_options = "--single -F -O -c search_path=pg_catalog -c exit_on_error=true";
138
139
140 /* path to 'initdb' binary directory */
141 static char bin_path[MAXPGPATH];
142 static char backend_exec[MAXPGPATH];
143
144 static void *pg_malloc(size_t size);
145 static char *xstrdup(const char *s);
146 static char **replace_token(char **lines,
147 const char *token, const char *replacement);
148
149 #ifndef HAVE_UNIX_SOCKETS
150 static char **filter_lines_with_token(char **lines, const char *token);
151 #endif
152 static char **readfile(char *path);
153 static void writefile(char *path, char **lines);
154 static FILE *popen_check(const char *command, const char *mode);
155 static int mkdir_p(char *path, mode_t omode);
156 static void exit_nicely(void);
157 static char *get_id(void);
158 static char *get_encoding_id(char *encoding_name);
159 static char *get_short_version(void);
160 static int check_data_dir(char *dir);
161 static bool mkdatadir(const char *subdir);
162 static void set_input(char **dest, char *filename);
163 static void check_input(char *path);
164 static void set_short_version(char *short_version, char *extrapath);
165 static void set_null_conf(void);
166 static void test_config_settings(void);
167 static void setup_config(void);
168 static void bootstrap_template1(char *short_version);
169 static void setup_auth(void);
170 static void get_set_pwd(void);
171 static void setup_depend(void);
172 static void setup_sysviews(void);
173 static void setup_description(void);
174 static void setup_conversion(void);
175 static void setup_dictionary(void);
176 static void setup_privileges(void);
177 static void set_info_version(void);
178 static void setup_schema(void);
179 static void vacuum_db(void);
180 static void make_template0(void);
181 static void make_postgres(void);
182 static void trapsig(int signum);
183 static void check_ok(void);
184 static char *escape_quotes(const char *src);
185 static int locale_date_order(const char *locale);
186 static bool check_locale_name(const char *locale);
187 static bool check_locale_encoding(const char *locale, int encoding);
188 static void setlocales(void);
189 static void usage(const char *progname);
190
191 #ifdef WIN32
192 static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo);
193 #endif
194
195
196 /*
197 * macros for running pipes to postgres
198 */
199 #define PG_CMD_DECL char cmd[MAXPGPATH]; FILE *cmdfd
200
201 #define PG_CMD_OPEN \
202 do { \
203 cmdfd = popen_check(cmd, "w"); \
204 if (cmdfd == NULL) \
205 exit_nicely(); /* message already printed by popen_check */ \
206 } while (0)
207
208 #define PG_CMD_CLOSE \
209 do { \
210 if (pclose_check(cmdfd)) \
211 exit_nicely(); /* message already printed by pclose_check */ \
212 } while (0)
213
214 #define PG_CMD_PUTS(line) \
215 do { \
216 if (fputs(line, cmdfd) < 0 || fflush(cmdfd) < 0) \
217 output_failed = true, output_errno = errno; \
218 } while (0)
219
220 #define PG_CMD_PRINTF1(fmt, arg1) \
221 do { \
222 if (fprintf(cmdfd, fmt, arg1) < 0 || fflush(cmdfd) < 0) \
223 output_failed = true, output_errno = errno; \
224 } while (0)
225
226 #define PG_CMD_PRINTF2(fmt, arg1, arg2) \
227 do { \
228 if (fprintf(cmdfd, fmt, arg1, arg2) < 0 || fflush(cmdfd) < 0) \
229 output_failed = true, output_errno = errno; \
230 } while (0)
231
232 #ifndef WIN32
233 #define QUOTE_PATH ""
234 #define DIR_SEP "/"
235 #else
236 #define QUOTE_PATH "\""
237 #define DIR_SEP "\\"
238 #endif
239
240 /*
241 * routines to check mem allocations and fail noisily.
242 *
243 * Note that we can't call exit_nicely() on a memory failure, as it calls
244 * rmtree() which needs memory allocation. So we just exit with a bang.
245 */
246 static void *
247 pg_malloc(size_t size)
248 {
249 void *result;
250
251 result = malloc(size);
252 if (!result)
253 {
254 fprintf(stderr, _("%s: out of memory\n"), progname);
255 exit(1);
256 }
257 return result;
258 }
259
260 static char *
261 xstrdup(const char *s)
262 {
263 char *result;
264
265 result = strdup(s);
266 if (!result)
267 {
268 fprintf(stderr, _("%s: out of memory\n"), progname);
269 exit(1);
270 }
271 return result;
272 }
273
274 /*
275 * make a copy of the array of lines, with token replaced by replacement
276 * the first time it occurs on each line.
277 *
278 * This does most of what sed was used for in the shell script, but
279 * doesn't need any regexp stuff.
280 */
281 static char **
282 replace_token(char **lines, const char *token, const char *replacement)
283 {
284 int numlines = 1;
285 int i;
286 char **result;
287 int toklen,
288 replen,
289 diff;
290
291 for (i = 0; lines[i]; i++)
292 numlines++;
293
294 result = (char **) pg_malloc(numlines * sizeof(char *));
295
296 toklen = strlen(token);
297 replen = strlen(replacement);
298 diff = replen - toklen;
299
300 for (i = 0; i < numlines; i++)
301 {
302 char *where;
303 char *newline;
304 int pre;
305
306 /* just copy pointer if NULL or no change needed */
307 if (lines[i] == NULL || (where = strstr(lines[i], token)) == NULL)
308 {
309 result[i] = lines[i];
310 continue;
311 }
312
313 /* if we get here a change is needed - set up new line */
314
315 newline = (char *) pg_malloc(strlen(lines[i]) + diff + 1);
316
317 pre = where - lines[i];
318
319 strncpy(newline, lines[i], pre);
320
321 strcpy(newline + pre, replacement);
322
323 strcpy(newline + pre + replen, lines[i] + pre + toklen);
324
325 result[i] = newline;
326 }
327
328 return result;
329 }
330
331 /*
332 * make a copy of lines without any that contain the token
333 *
334 * a sort of poor man's grep -v
335 */
336 #ifndef HAVE_UNIX_SOCKETS
337 static char **
338 filter_lines_with_token(char **lines, const char *token)
339 {
340 int numlines = 1;
341 int i,
342 src,
343 dst;
344 char **result;
345
346 for (i = 0; lines[i]; i++)
347 numlines++;
348
349 result = (char **) pg_malloc(numlines * sizeof(char *));
350
351 for (src = 0, dst = 0; src < numlines; src++)
352 {
353 if (lines[src] == NULL || strstr(lines[src], token) == NULL)
354 result[dst++] = lines[src];
355 }
356
357 return result;
358 }
359 #endif
360
361 /*
362 * get the lines from a text file
363 */
364 static char **
365 readfile(char *path)
366 {
367 FILE *infile;
368 int maxlength = 0,
369 linelen = 0;
370 int nlines = 0;
371 char **result;
372 char *buffer;
373 int c;
374
375 if ((infile = fopen(path, "r")) == NULL)
376 {
377 fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
378 progname, path, strerror(errno));
379 exit_nicely();
380 }
381
382 /* pass over the file twice - the first time to size the result */
383
384 while ((c = fgetc(infile)) != EOF)
385 {
386 linelen++;
387 if (c == '\n')
388 {
389 nlines++;
390 if (linelen > maxlength)
391 maxlength = linelen;
392 linelen = 0;
393 }
394 }
395
396 /* handle last line without a terminating newline (yuck) */
397
398 if (linelen)
399 nlines++;
400 if (linelen > maxlength)
401 maxlength = linelen;
402
403 /* set up the result and the line buffer */
404
405 result = (char **) pg_malloc((nlines + 2) * sizeof(char *));
406 buffer = (char *) pg_malloc(maxlength + 2);
407
408 /* now reprocess the file and store the lines */
409
410 rewind(infile);
411 nlines = 0;
412 while (fgets(buffer, maxlength + 1, infile) != NULL)
413 {
414 result[nlines] = xstrdup(buffer);
415 nlines++;
416 }
417
418 fclose(infile);
419 free(buffer);
420 result[nlines] = NULL;
421
422 return result;
423 }
424
425 /*
426 * write an array of lines to a file
427 *
428 * This is only used to write text files. Use fopen "w" not PG_BINARY_W
429 * so that the resulting configuration files are nicely editable on Windows.
430 */
431 static void
432 writefile(char *path, char **lines)
433 {
434 FILE *out_file;
435 char **line;
436
437 if ((out_file = fopen(path, "w")) == NULL)
438 {
439 fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
440 progname, path, strerror(errno));
441 exit_nicely();
442 }
443 for (line = lines; *line != NULL; line++)
444 {
445 if (fputs(*line, out_file) < 0)
446 {
447 fprintf(stderr, _("%s: could not write file \"%s\": %s\n"),
448 progname, path, strerror(errno));
449 exit_nicely();
450 }
451 free(*line);
452 }
453 if (fclose(out_file))
454 {
455 fprintf(stderr, _("%s: could not write file \"%s\": %s\n"),
456 progname, path, strerror(errno));
457 exit_nicely();
458 }
459 }
460
461 /*
462 * Open a subcommand with suitable error messaging
463 */
464 static FILE *
465 popen_check(const char *command, const char *mode)
466 {
467 FILE *cmdfd;
468
469 fflush(stdout);
470 fflush(stderr);
471 errno = 0;
472 cmdfd = popen(command, mode);
473 if (cmdfd == NULL)
474 fprintf(stderr, _("%s: could not execute command \"%s\": %s\n"),
475 progname, command, strerror(errno));
476 return cmdfd;
477 }
478
479 /* source stolen from FreeBSD /src/bin/mkdir/mkdir.c and adapted */
480
481 /*
482 * this tries to build all the elements of a path to a directory a la mkdir -p
483 * we assume the path is in canonical form, i.e. uses / as the separator
484 * we also assume it isn't null.
485 *
486 * note that on failure, the path arg has been modified to show the particular
487 * directory level we had problems with.
488 */
489 static int
490 mkdir_p(char *path, mode_t omode)
491 {
492 struct stat sb;
493 mode_t numask,
494 oumask;
495 int first,
496 last,
497 retval;
498 char *p;
499
500 p = path;
501 oumask = 0;
502 retval = 0;
503
504 #ifdef WIN32
505 /* skip network and drive specifiers for win32 */
506 if (strlen(p) >= 2)
507 {
508 if (p[0] == '/' && p[1] == '/')
509 {
510 /* network drive */
511 p = strstr(p + 2, "/");
512 if (p == NULL)
513 return 1;
514 }
515 else if (p[1] == ':' &&
516 ((p[0] >= 'a' && p[0] <= 'z') ||
517 (p[0] >= 'A' && p[0] <= 'Z')))
518 {
519 /* local drive */
520 p += 2;
521 }
522 }
523 #endif
524
525 if (p[0] == '/') /* Skip leading '/'. */
526 ++p;
527 for (first = 1, last = 0; !last; ++p)
528 {
529 if (p[0] == '\0')
530 last = 1;
531 else if (p[0] != '/')
532 continue;
533 *p = '\0';
534 if (!last && p[1] == '\0')
535 last = 1;
536 if (first)
537 {
538 /*
539 * POSIX 1003.2: For each dir operand that does not name an
540 * existing directory, effects equivalent to those caused by the
541 * following command shall occcur:
542 *
543 * mkdir -p -m $(umask -S),u+wx $(dirname dir) && mkdir [-m mode]
544 * dir
545 *
546 * We change the user's umask and then restore it, instead of
547 * doing chmod's.
548 */
549 oumask = umask(0);
550 numask = oumask & ~(S_IWUSR | S_IXUSR);
551 (void) umask(numask);
552 first = 0;
553 }
554 if (last)
555 (void) umask(oumask);
556
557 /* check for pre-existing directory; ok if it's a parent */
558 if (stat(path, &sb) == 0)
559 {
560 if (!S_ISDIR(sb.st_mode))
561 {
562 if (last)
563 errno = EEXIST;
564 else
565 errno = ENOTDIR;
566 retval = 1;
567 break;
568 }
569 }
570 else if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0)
571 {
572 retval = 1;
573 break;
574 }
575 if (!last)
576 *p = '/';
577 }
578 if (!first && !last)
579 (void) umask(oumask);
580 return retval;
581 }
582
583 /*
584 * clean up any files we created on failure
585 * if we created the data directory remove it too
586 */
587 static void
588 exit_nicely(void)
589 {
590 if (!noclean)
591 {
592 if (made_new_pgdata)
593 {
594 fprintf(stderr, _("%s: removing data directory \"%s\"\n"),
595 progname, pg_data);
596 if (!rmtree(pg_data, true))
597 fprintf(stderr, _("%s: failed to remove data directory\n"),
598 progname);
599 }
600 else if (found_existing_pgdata)
601 {
602 fprintf(stderr,
603 _("%s: removing contents of data directory \"%s\"\n"),
604 progname, pg_data);
605 if (!rmtree(pg_data, false))
606 fprintf(stderr, _("%s: failed to remove contents of data directory\n"),
607 progname);
608 }
609
610 if (made_new_xlogdir)
611 {
612 fprintf(stderr, _("%s: removing transaction log directory \"%s\"\n"),
613 progname, xlog_dir);
614 if (!rmtree(xlog_dir, true))
615 fprintf(stderr, _("%s: failed to remove transaction log directory\n"),
616 progname);
617 }
618 else if (found_existing_xlogdir)
619 {
620 fprintf(stderr,
621 _("%s: removing contents of transaction log directory \"%s\"\n"),
622 progname, xlog_dir);
623 if (!rmtree(xlog_dir, false))
624 fprintf(stderr, _("%s: failed to remove contents of transaction log directory\n"),
625 progname);
626 }
627 /* otherwise died during startup, do nothing! */
628 }
629 else
630 {
631 if (made_new_pgdata || found_existing_pgdata)
632 fprintf(stderr,
633 _("%s: data directory \"%s\" not removed at user's request\n"),
634 progname, pg_data);
635
636 if (made_new_xlogdir || found_existing_xlogdir)
637 fprintf(stderr,
638 _("%s: transaction log directory \"%s\" not removed at user's request\n"),
639 progname, xlog_dir);
640 }
641
642 exit(1);
643 }
644
645 /*
646 * find the current user
647 *
648 * on unix make sure it isn't really root
649 */
650 static char *
651 get_id(void)
652 {
653 #ifndef WIN32
654
655 struct passwd *pw;
656
657 if (geteuid() == 0) /* 0 is root's uid */
658 {
659 fprintf(stderr,
660 _("%s: cannot be run as root\n"
661 "Please log in (using, e.g., \"su\") as the "
662 "(unprivileged) user that will\n"
663 "own the server process.\n"),
664 progname);
665 exit(1);
666 }
667
668 pw = getpwuid(geteuid());
669 if (!pw)
670 {
671 fprintf(stderr,
672 _("%s: could not obtain information about current user: %s\n"),
673 progname, strerror(errno));
674 exit(1);
675 }
676 #else /* the windows code */
677
678 struct passwd_win32
679 {
680 int pw_uid;
681 char pw_name[128];
682 } pass_win32;
683 struct passwd_win32 *pw = &pass_win32;
684 DWORD pwname_size = sizeof(pass_win32.pw_name) - 1;
685
686 pw->pw_uid = 1;
687 if (!GetUserName(pw->pw_name, &pwname_size))
688 {
689 fprintf(stderr, _("%s: could not get current user name: %s\n"),
690 progname, strerror(errno));
691 exit(1);
692 }
693 #endif
694
695 return xstrdup(pw->pw_name);
696 }
697
698 static char *
699 encodingid_to_string(int enc)
700 {
701 char result[20];
702
703 sprintf(result, "%d", enc);
704 return xstrdup(result);
705 }
706
707 /*
708 * get the encoding id for a given encoding name
709 */
710 static char *
711 get_encoding_id(char *encoding_name)
712 {
713 int enc;
714
715 if (encoding_name && *encoding_name)
716 {
717 if ((enc = pg_valid_server_encoding(encoding_name)) >= 0)
718 return encodingid_to_string(enc);
719 }
720 fprintf(stderr, _("%s: \"%s\" is not a valid server encoding name\n"),
721 progname, encoding_name ? encoding_name : "(null)");
722 exit(1);
723 }
724
725 /*
726 * Support for determining the best default text search configuration.
727 * We key this off the first part of LC_CTYPE (ie, the language name).
728 */
729 struct tsearch_config_match
730 {
731 const char *tsconfname;
732 const char *langname;
733 };
734
735 static const struct tsearch_config_match tsearch_config_languages[] =
736 {
737 {"danish", "da"},
738 {"danish", "Danish"},
739 {"dutch", "nl"},
740 {"dutch", "Dutch"},
741 {"english", "C"},
742 {"english", "POSIX"},
743 {"english", "en"},
744 {"english", "English"},
745 {"finnish", "fi"},
746 {"finnish", "Finnish"},
747 {"french", "fr"},
748 {"french", "French"},
749 {"german", "de"},
750 {"german", "German"},
751 {"hungarian", "hu"},
752 {"hungarian", "Hungarian"},
753 {"italian", "it"},
754 {"italian", "Italian"},
755 {"norwegian", "no"},
756 {"norwegian", "Norwegian"},
757 {"portuguese", "pt"},
758 {"portuguese", "Portuguese"},
759 {"romanian", "ro"},
760 {"russian", "ru"},
761 {"russian", "Russian"},
762 {"spanish", "es"},
763 {"spanish", "Spanish"},
764 {"swedish", "sv"},
765 {"swedish", "Swedish"},
766 {"turkish", "tr"},
767 {"turkish", "Turkish"},
768 {NULL, NULL} /* end marker */
769 };
770
771 /*
772 * Look for a text search configuration matching lc_ctype, and return its
773 * name; return NULL if no match.
774 */
775 static const char *
776 find_matching_ts_config(const char *lc_type)
777 {
778 int i;
779 char *langname,
780 *ptr;
781
782 /*
783 * Convert lc_ctype to a language name by stripping everything after an
784 * underscore. Just for paranoia, we also stop at '.' or '@'.
785 */
786 if (lc_type == NULL)
787 langname = xstrdup("");
788 else
789 {
790 ptr = langname = xstrdup(lc_type);
791 while (*ptr && *ptr != '_' && *ptr != '.' && *ptr != '@')
792 ptr++;
793 *ptr = '\0';
794 }
795
796 for (i = 0; tsearch_config_languages[i].tsconfname; i++)
797 {
798 if (pg_strcasecmp(tsearch_config_languages[i].langname, langname) == 0)
799 {
800 free(langname);
801 return tsearch_config_languages[i].tsconfname;
802 }
803 }
804
805 free(langname);
806 return NULL;
807 }
808
809
810 /*
811 * get short version of VERSION
812 */
813 static char *
814 get_short_version(void)
815 {
816 bool gotdot = false;
817 int end;
818 char *vr;
819
820 vr = xstrdup(PG_VERSION);
821
822 for (end = 0; vr[end] != '\0'; end++)
823 {
824 if (vr[end] == '.')
825 {
826 if (end == 0)
827 return NULL;
828 else if (gotdot)
829 break;
830 else
831 gotdot = true;
832 }
833 else if (vr[end] < '0' || vr[end] > '9')
834 {
835 /* gone past digits and dots */
836 break;
837 }
838 }
839 if (end == 0 || vr[end - 1] == '.' || !gotdot)
840 return NULL;
841
842 vr[end] = '\0';
843 return vr;
844 }
845
846 /*
847 * make sure the directory either doesn't exist or is empty
848 *
849 * Returns 0 if nonexistent, 1 if exists and empty, 2 if not empty,
850 * or -1 if trouble accessing directory
851 */
852 static int
853 check_data_dir(char *dir)
854 {
855 DIR *chkdir;
856 struct dirent *file;
857 int result = 1;
858
859 errno = 0;
860
861 chkdir = opendir(dir);
862
863 if (!chkdir)
864 return (errno == ENOENT) ? 0 : -1;
865
866 while ((file = readdir(chkdir)) != NULL)
867 {
868 if (strcmp(".", file->d_name) == 0 ||
869 strcmp("..", file->d_name) == 0)
870 {
871 /* skip this and parent directory */
872 continue;
873 }
874 else
875 {
876 result = 2; /* not empty */
877 break;
878 }
879 }
880
881 #ifdef WIN32
882
883 /*
884 * This fix is in mingw cvs (runtime/mingwex/dirent.c rev 1.4), but not in
885 * released version
886 */
887 if (GetLastError() == ERROR_NO_MORE_FILES)
888 errno = 0;
889 #endif
890
891 closedir(chkdir);
892
893 if (errno != 0)
894 result = -1; /* some kind of I/O error? */
895
896 return result;
897 }
898
899 /*
900 * make the data directory (or one of its subdirectories if subdir is not NULL)
901 */
902 static bool
903 mkdatadir(const char *subdir)
904 {
905 char *path;
906
907 path = pg_malloc(strlen(pg_data) + 2 +
908 (subdir == NULL ? 0 : strlen(subdir)));
909
910 if (subdir != NULL)
911 sprintf(path, "%s/%s", pg_data, subdir);
912 else
913 strcpy(path, pg_data);
914
915 if (mkdir_p(path, 0700) == 0)
916 return true;
917
918 fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
919 progname, path, strerror(errno));
920
921 return false;
922 }
923
924
925 /*
926 * set name of given input file variable under data directory
927 */
928 static void
929 set_input(char **dest, char *filename)
930 {
931 *dest = pg_malloc(strlen(share_path) + strlen(filename) + 2);
932 sprintf(*dest, "%s/%s", share_path, filename);
933 }
934
935 /*
936 * check that given input file exists
937 */
938 static void
939 check_input(char *path)
940 {
941 struct stat statbuf;
942
943 if (stat(path, &statbuf) != 0)
944 {
945 if (errno == ENOENT)
946 {
947 fprintf(stderr,
948 _("%s: file \"%s\" does not exist\n"), progname, path);
949 fprintf(stderr,
950 _("This might mean you have a corrupted installation or identified\n"
951 "the wrong directory with the invocation option -L.\n"));
952 }
953 else
954 {
955 fprintf(stderr,
956 _("%s: could not access file \"%s\": %s\n"), progname, path,
957 strerror(errno));
958 fprintf(stderr,
959 _("This might mean you have a corrupted installation or identified\n"
960 "the wrong directory with the invocation option -L.\n"));
961 }
962 exit(1);
963 }
964 if (!S_ISREG(statbuf.st_mode))
965 {
966 fprintf(stderr,
967 _("%s: file \"%s\" is not a regular file\n"), progname, path);
968 fprintf(stderr,
969 _("This might mean you have a corrupted installation or identified\n"
970 "the wrong directory with the invocation option -L.\n"));
971 exit(1);
972 }
973 }
974
975 /*
976 * write out the PG_VERSION file in the data dir, or its subdirectory
977 * if extrapath is not NULL
978 */
979 static void
980 set_short_version(char *short_version, char *extrapath)
981 {
982 FILE *version_file;
983 char *path;
984
985 if (extrapath == NULL)
986 {
987 path = pg_malloc(strlen(pg_data) + 12);
988 sprintf(path, "%s/PG_VERSION", pg_data);
989 }
990 else
991 {
992 path = pg_malloc(strlen(pg_data) + strlen(extrapath) + 13);
993 sprintf(path, "%s/%s/PG_VERSION", pg_data, extrapath);
994 }
995 version_file = fopen(path, PG_BINARY_W);
996 if (version_file == NULL)
997 {
998 fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
999 progname, path, strerror(errno));
1000 exit_nicely();
1001 }
1002 if (fprintf(version_file, "%s\n", short_version) < 0 ||
1003 fclose(version_file))
1004 {
1005 fprintf(stderr, _("%s: could not write file \"%s\": %s\n"),
1006 progname, path, strerror(errno));
1007 exit_nicely();
1008 }
1009 free(path);
1010 }
1011
1012 /*
1013 * set up an empty config file so we can check config settings by launching
1014 * a test backend
1015 */
1016 static void
1017 set_null_conf(void)
1018 {
1019 FILE *conf_file;
1020 char *path;
1021
1022 path = pg_malloc(strlen(pg_data) + 17);
1023 sprintf(path, "%s/postgresql.conf", pg_data);
1024 conf_file = fopen(path, PG_BINARY_W);
1025 if (conf_file == NULL)
1026 {
1027 fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1028 progname, path, strerror(errno));
1029 exit_nicely();
1030 }
1031 if (fclose(conf_file))
1032 {
1033 fprintf(stderr, _("%s: could not write file \"%s\": %s\n"),
1034 progname, path, strerror(errno));
1035 exit_nicely();
1036 }
1037 free(path);
1038 }
1039
1040 /*
1041 * Determine platform-specific config settings
1042 *
1043 * Use reasonable values if kernel will let us, else scale back. Probe
1044 * for max_connections first since it is subject to more constraints than
1045 * shared_buffers.
1046 */
1047 static void
1048 test_config_settings(void)
1049 {
1050 /*
1051 * This macro defines the minimum shared_buffers we want for a given
1052 * max_connections value. The arrays show the settings to try.
1053 */
1054 #define MIN_BUFS_FOR_CONNS(nconns) ((nconns) * 10)
1055
1056 static const int trial_conns[] = {
1057 100, 50, 40, 30, 20, 10
1058 };
1059 static const int trial_bufs[] = {
1060 4096, 3584, 3072, 2560, 2048, 1536,
1061 1000, 900, 800, 700, 600, 500,
1062 400, 300, 200, 100, 50
1063 };
1064
1065 char cmd[MAXPGPATH];
1066 const int connslen = sizeof(trial_conns) / sizeof(int);
1067 const int bufslen = sizeof(trial_bufs) / sizeof(int);
1068 int i,
1069 status,
1070 test_conns,
1071 test_buffs,
1072 ok_buffers = 0;
1073
1074
1075 printf(_("selecting default max_connections ... "));
1076 fflush(stdout);
1077
1078 for (i = 0; i < connslen; i++)
1079 {
1080 test_conns = trial_conns[i];
1081 test_buffs = MIN_BUFS_FOR_CONNS(test_conns);
1082
1083 snprintf(cmd, sizeof(cmd),
1084 SYSTEMQUOTE "\"%s\" --boot -x0 %s "
1085 "-c max_connections=%d "
1086 "-c shared_buffers=%d "
1087 "< \"%s\" > \"%s\" 2>&1" SYSTEMQUOTE,
1088 backend_exec, boot_options,
1089 test_conns, test_buffs,
1090 DEVNULL, DEVNULL);
1091 status = system(cmd);
1092 if (status == 0)
1093 {
1094 ok_buffers = test_buffs;
1095 break;
1096 }
1097 }
1098 if (i >= connslen)
1099 i = connslen - 1;
1100 n_connections = trial_conns[i];
1101
1102 printf("%d\n", n_connections);
1103
1104 printf(_("selecting default shared_buffers ... "));
1105 fflush(stdout);
1106
1107 for (i = 0; i < bufslen; i++)
1108 {
1109 /* Use same amount of memory, independent of BLCKSZ */
1110 test_buffs = (trial_bufs[i] * 8192) / BLCKSZ;
1111 if (test_buffs <= ok_buffers)
1112 {
1113 test_buffs = ok_buffers;
1114 break;
1115 }
1116
1117 snprintf(cmd, sizeof(cmd),
1118 SYSTEMQUOTE "\"%s\" --boot -x0 %s "
1119 "-c max_connections=%d "
1120 "-c shared_buffers=%d "
1121 "< \"%s\" > \"%s\" 2>&1" SYSTEMQUOTE,
1122 backend_exec, boot_options,
1123 n_connections, test_buffs,
1124 DEVNULL, DEVNULL);
1125 status = system(cmd);
1126 if (status == 0)
1127 break;
1128 }
1129 n_buffers = test_buffs;
1130
1131 if ((n_buffers * (BLCKSZ / 1024)) % 1024 == 0)
1132 printf("%dMB\n", (n_buffers * (BLCKSZ / 1024)) / 1024);
1133 else
1134 printf("%dkB\n", n_buffers * (BLCKSZ / 1024));
1135 }
1136
1137 /*
1138 * set up all the config files
1139 */
1140 static void
1141 setup_config(void)
1142 {
1143 char **conflines;
1144 char repltok[100];
1145 char path[MAXPGPATH];
1146
1147 fputs(_("creating configuration files ... "), stdout);
1148 fflush(stdout);
1149
1150 /* postgresql.conf */
1151
1152 conflines = readfile(conf_file);
1153
1154 snprintf(repltok, sizeof(repltok), "max_connections = %d", n_connections);
1155 conflines = replace_token(conflines, "#max_connections = 100", repltok);
1156
1157 if ((n_buffers * (BLCKSZ / 1024)) % 1024 == 0)
1158 snprintf(repltok, sizeof(repltok), "shared_buffers = %dMB",
1159 (n_buffers * (BLCKSZ / 1024)) / 1024);
1160 else
1161 snprintf(repltok, sizeof(repltok), "shared_buffers = %dkB",
1162 n_buffers * (BLCKSZ / 1024));
1163 conflines = replace_token(conflines, "#shared_buffers = 32MB", repltok);
1164
1165 #if DEF_PGPORT != 5432
1166 snprintf(repltok, sizeof(repltok), "#port = %d", DEF_PGPORT);
1167 conflines = replace_token(conflines, "#port = 5432", repltok);
1168 #endif
1169
1170 snprintf(repltok, sizeof(repltok), "lc_messages = '%s'",
1171 escape_quotes(lc_messages));
1172 conflines = replace_token(conflines, "#lc_messages = 'C'", repltok);
1173
1174 snprintf(repltok, sizeof(repltok), "lc_monetary = '%s'",
1175 escape_quotes(lc_monetary));
1176 conflines = replace_token(conflines, "#lc_monetary = 'C'", repltok);
1177
1178 snprintf(repltok, sizeof(repltok), "lc_numeric = '%s'",
1179 escape_quotes(lc_numeric));
1180 conflines = replace_token(conflines, "#lc_numeric = 'C'", repltok);
1181
1182 snprintf(repltok, sizeof(repltok), "lc_time = '%s'",
1183 escape_quotes(lc_time));
1184 conflines = replace_token(conflines, "#lc_time = 'C'", repltok);
1185
1186 switch (locale_date_order(lc_time))
1187 {
1188 case DATEORDER_YMD:
1189 strcpy(repltok, "datestyle = 'iso, ymd'");
1190 break;
1191 case DATEORDER_DMY:
1192 strcpy(repltok, "datestyle = 'iso, dmy'");
1193 break;
1194 case DATEORDER_MDY:
1195 default:
1196 strcpy(repltok, "datestyle = 'iso, mdy'");
1197 break;
1198 }
1199 conflines = replace_token(conflines, "#datestyle = 'iso, mdy'", repltok);
1200
1201 snprintf(repltok, sizeof(repltok),
1202 "default_text_search_config = 'pg_catalog.%s'",
1203 escape_quotes(default_text_search_config));
1204 conflines = replace_token(conflines,
1205 "#default_text_search_config = 'pg_catalog.simple'",
1206 repltok);
1207
1208 snprintf(path, sizeof(path), "%s/postgresql.conf", pg_data);
1209
1210 writefile(path, conflines);
1211 chmod(path, 0600);
1212
1213 free(conflines);
1214
1215
1216 /* pg_hba.conf */
1217
1218 conflines = readfile(hba_file);
1219
1220 #ifndef HAVE_UNIX_SOCKETS
1221 conflines = filter_lines_with_token(conflines, "@remove-line-for-nolocal@");
1222 #else
1223 conflines = replace_token(conflines, "@remove-line-for-nolocal@", "");
1224 #endif
1225
1226 #ifdef HAVE_IPV6
1227
1228 /*
1229 * Probe to see if there is really any platform support for IPv6, and
1230 * comment out the relevant pg_hba line if not. This avoids runtime
1231 * warnings if getaddrinfo doesn't actually cope with IPv6. Particularly
1232 * useful on Windows, where executables built on a machine with IPv6 may
1233 * have to run on a machine without.
1234 */
1235 {
1236 struct addrinfo *gai_result;
1237 struct addrinfo hints;
1238 int err = 0;
1239
1240 #ifdef WIN32
1241 /* need to call WSAStartup before calling getaddrinfo */
1242 WSADATA wsaData;
1243
1244 err = WSAStartup(MAKEWORD(2, 2), &wsaData);
1245 #endif
1246
1247 /* for best results, this code should match parse_hba() */
1248 hints.ai_flags = AI_NUMERICHOST;
1249 hints.ai_family = PF_UNSPEC;
1250 hints.ai_socktype = 0;
1251 hints.ai_protocol = 0;
1252 hints.ai_addrlen = 0;
1253 hints.ai_canonname = NULL;
1254 hints.ai_addr = NULL;
1255 hints.ai_next = NULL;
1256
1257 if (err != 0 ||
1258 getaddrinfo("::1", NULL, &hints, &gai_result) != 0)
1259 conflines = replace_token(conflines,
1260 "host all all ::1",
1261 "#host all all ::1");
1262 }
1263 #else /* !HAVE_IPV6 */
1264 /* If we didn't compile IPV6 support at all, always comment it out */
1265 conflines = replace_token(conflines,
1266 "host all all ::1",
1267 "#host all all ::1");
1268 #endif /* HAVE_IPV6 */
1269
1270 /* Replace default authentication methods */
1271 conflines = replace_token(conflines,
1272 "@authmethod@",
1273 authmethod);
1274
1275 conflines = replace_token(conflines,
1276 "@authcomment@",
1277 strcmp(authmethod, "trust") ? "" : AUTHTRUST_WARNING);
1278
1279 snprintf(path, sizeof(path), "%s/pg_hba.conf", pg_data);
1280
1281 writefile(path, conflines);
1282 chmod(path, 0600);
1283
1284 free(conflines);
1285
1286 /* pg_ident.conf */
1287
1288 conflines = readfile(ident_file);
1289
1290 snprintf(path, sizeof(path), "%s/pg_ident.conf", pg_data);
1291
1292 writefile(path, conflines);
1293 chmod(path, 0600);
1294
1295 free(conflines);
1296
1297 check_ok();
1298 }
1299
1300
1301 /*
1302 * run the BKI script in bootstrap mode to create template1
1303 */
1304 static void
1305 bootstrap_template1(char *short_version)
1306 {
1307 PG_CMD_DECL;
1308 char **line;
1309 char *talkargs = "";
1310 char **bki_lines;
1311 char headerline[MAXPGPATH];
1312 char buf[64];
1313
1314 printf(_("creating template1 database in %s/base/1 ... "), pg_data);
1315 fflush(stdout);
1316
1317 if (debug)
1318 talkargs = "-d 5";
1319
1320 bki_lines = readfile(bki_file);
1321
1322 /* Check that bki file appears to be of the right version */
1323
1324 snprintf(headerline, sizeof(headerline), "# PostgreSQL %s\n",
1325 short_version);
1326
1327 if (strcmp(headerline, *bki_lines) != 0)
1328 {
1329 fprintf(stderr,
1330 _("%s: input file \"%s\" does not belong to PostgreSQL %s\n"
1331 "Check your installation or specify the correct path "
1332 "using the option -L.\n"),
1333 progname, bki_file, PG_VERSION);
1334 exit_nicely();
1335 }
1336
1337 /* Substitute for various symbols used in the BKI file */
1338
1339 sprintf(buf, "%d", NAMEDATALEN);
1340 bki_lines = replace_token(bki_lines, "NAMEDATALEN", buf);
1341
1342 sprintf(buf, "%d", (int) sizeof(Pointer));
1343 bki_lines = replace_token(bki_lines, "SIZEOF_POINTER", buf);
1344
1345 bki_lines = replace_token(bki_lines, "ALIGNOF_POINTER",
1346 (sizeof(Pointer) == 4) ? "i" : "d");
1347
1348 bki_lines = replace_token(bki_lines, "FLOAT4PASSBYVAL",
1349 FLOAT4PASSBYVAL ? "true" : "false");
1350
1351 bki_lines = replace_token(bki_lines, "FLOAT8PASSBYVAL",
1352 FLOAT8PASSBYVAL ? "true" : "false");
1353
1354 bki_lines = replace_token(bki_lines, "POSTGRES", username);
1355
1356 bki_lines = replace_token(bki_lines, "ENCODING", encodingid);
1357
1358 bki_lines = replace_token(bki_lines, "LC_COLLATE", lc_collate);
1359
1360 bki_lines = replace_token(bki_lines, "LC_CTYPE", lc_ctype);
1361
1362 /*
1363 * Pass correct LC_xxx environment to bootstrap.
1364 *
1365 * The shell script arranged to restore the LC settings afterwards, but
1366 * there doesn't seem to be any compelling reason to do that.
1367 */
1368 snprintf(cmd, sizeof(cmd), "LC_COLLATE=%s", lc_collate);
1369 putenv(xstrdup(cmd));
1370
1371 snprintf(cmd, sizeof(cmd), "LC_CTYPE=%s", lc_ctype);
1372 putenv(xstrdup(cmd));
1373
1374 unsetenv("LC_ALL");
1375
1376 /* Also ensure backend isn't confused by this environment var: */
1377 unsetenv("PGCLIENTENCODING");
1378
1379 snprintf(cmd, sizeof(cmd),
1380 "\"%s\" --boot -x1 %s %s",
1381 backend_exec, boot_options, talkargs);
1382
1383 PG_CMD_OPEN;
1384
1385 for (line = bki_lines; *line != NULL; line++)
1386 {
1387 PG_CMD_PUTS(*line);
1388 free(*line);
1389 }
1390
1391 PG_CMD_CLOSE;
1392
1393 free(bki_lines);
1394
1395 check_ok();
1396 }
1397
1398 /*
1399 * set up the shadow password table
1400 */
1401 static void
1402 setup_auth(void)
1403 {
1404 PG_CMD_DECL;
1405 const char **line;
1406 static const char *pg_authid_setup[] = {
1407 /*
1408 * Create triggers to ensure manual updates to shared catalogs will be
1409 * reflected into their "flat file" copies.
1410 */
1411 "CREATE TRIGGER pg_sync_pg_database "
1412 " AFTER INSERT OR UPDATE OR DELETE ON pg_database "
1413 " FOR EACH STATEMENT EXECUTE PROCEDURE flatfile_update_trigger();\n",
1414 "CREATE TRIGGER pg_sync_pg_authid "
1415 " AFTER INSERT OR UPDATE OR DELETE ON pg_authid "
1416 " FOR EACH STATEMENT EXECUTE PROCEDURE flatfile_update_trigger();\n",
1417 "CREATE TRIGGER pg_sync_pg_auth_members "
1418 " AFTER INSERT OR UPDATE OR DELETE ON pg_auth_members "
1419 " FOR EACH STATEMENT EXECUTE PROCEDURE flatfile_update_trigger();\n",
1420
1421 /*
1422 * The authid table shouldn't be readable except through views, to
1423 * ensure passwords are not publicly visible.
1424 */
1425 "REVOKE ALL on pg_authid FROM public;\n",
1426 NULL
1427 };
1428
1429 fputs(_("initializing pg_authid ... "), stdout);
1430 fflush(stdout);
1431
1432 snprintf(cmd, sizeof(cmd),
1433 "\"%s\" %s template1 >%s",
1434 backend_exec, backend_options,
1435 DEVNULL);
1436
1437 PG_CMD_OPEN;
1438
1439 for (line = pg_authid_setup; *line != NULL; line++)
1440 PG_CMD_PUTS(*line);
1441
1442 PG_CMD_CLOSE;
1443
1444 check_ok();
1445 }
1446
1447 /*
1448 * get the superuser password if required, and call postgres to set it
1449 */
1450 static void
1451 get_set_pwd(void)
1452 {
1453 PG_CMD_DECL;
1454
1455 char *pwd1,
1456 *pwd2;
1457 char pwdpath[MAXPGPATH];
1458 struct stat statbuf;
1459
1460 if (pwprompt)
1461 {
1462 /*
1463 * Read password from terminal
1464 */
1465 pwd1 = simple_prompt("Enter new superuser password: ", 100, false);
1466 pwd2 = simple_prompt("Enter it again: ", 100, false);
1467 if (strcmp(pwd1, pwd2) != 0)
1468 {
1469 fprintf(stderr, _("Passwords didn't match.\n"));
1470 exit_nicely();
1471 }
1472 free(pwd2);
1473 }
1474 else
1475 {
1476 /*
1477 * Read password from file
1478 *
1479 * Ideally this should insist that the file not be world-readable.
1480 * However, this option is mainly intended for use on Windows where
1481 * file permissions may not exist at all, so we'll skip the paranoia
1482 * for now.
1483 */
1484 FILE *pwf = fopen(pwfilename, "r");
1485 char pwdbuf[MAXPGPATH];
1486 int i;
1487
1488 if (!pwf)
1489 {
1490 fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1491 progname, pwfilename, strerror(errno));
1492 exit_nicely();
1493 }
1494 if (!fgets(pwdbuf, sizeof(pwdbuf), pwf))
1495 {
1496 fprintf(stderr, _("%s: could not read password from file \"%s\": %s\n"),
1497 progname, pwfilename, strerror(errno));
1498 exit_nicely();
1499 }
1500 fclose(pwf);
1501
1502 i = strlen(pwdbuf);
1503 while (i > 0 && (pwdbuf[i - 1] == '\r' || pwdbuf[i - 1] == '\n'))
1504 pwdbuf[--i] = '\0';
1505
1506 pwd1 = xstrdup(pwdbuf);
1507
1508 }
1509 printf(_("setting password ... "));
1510 fflush(stdout);
1511
1512 snprintf(cmd, sizeof(cmd),
1513 "\"%s\" %s template1 >%s",
1514 backend_exec, backend_options,
1515 DEVNULL);
1516
1517 PG_CMD_OPEN;
1518
1519 PG_CMD_PRINTF2("ALTER USER \"%s\" WITH PASSWORD E'%s';\n",
1520 username, escape_quotes(pwd1));
1521
1522 /* MM: pwd1 is no longer needed, freeing it */
1523 free(pwd1);
1524
1525 PG_CMD_CLOSE;
1526
1527 check_ok();
1528
1529 snprintf(pwdpath, sizeof(pwdpath), "%s/global/pg_auth", pg_data);
1530 if (stat(pwdpath, &statbuf) != 0 || !S_ISREG(statbuf.st_mode))
1531 {
1532 fprintf(stderr,
1533 _("%s: The password file was not generated. "
1534 "Please report this problem.\n"),
1535 progname);
1536 exit_nicely();
1537 }
1538 }
1539
1540 /*
1541 * set up pg_depend
1542 */
1543 static void
1544 setup_depend(void)
1545 {
1546 PG_CMD_DECL;
1547 const char **line;
1548 static const char *pg_depend_setup[] = {
1549 /*
1550 * Make PIN entries in pg_depend for all objects made so far in the
1551 * tables that the dependency code handles. This is overkill (the
1552 * system doesn't really depend on having every last weird datatype,
1553 * for instance) but generating only the minimum required set of
1554 * dependencies seems hard.
1555 *
1556 * Note that we deliberately do not pin the system views, which
1557 * haven't been created yet. Also, no conversions, databases, or
1558 * tablespaces are pinned.
1559 *
1560 * First delete any already-made entries; PINs override all else, and
1561 * must be the only entries for their objects.
1562 */
1563 "DELETE FROM pg_depend;\n",
1564 "VACUUM pg_depend;\n",
1565 "DELETE FROM pg_shdepend;\n",
1566 "VACUUM pg_shdepend;\n",
1567
1568 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1569 " FROM pg_class;\n",
1570 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1571 " FROM pg_proc;\n",
1572 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1573 " FROM pg_type;\n",
1574 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1575 " FROM pg_cast;\n",
1576 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1577 " FROM pg_constraint;\n",
1578 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1579 " FROM pg_attrdef;\n",
1580 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1581 " FROM pg_language;\n",
1582 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1583 " FROM pg_operator;\n",
1584 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1585 " FROM pg_opclass;\n",
1586 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1587 " FROM pg_opfamily;\n",
1588 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1589 " FROM pg_amop;\n",
1590 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1591 " FROM pg_amproc;\n",
1592 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1593 " FROM pg_rewrite;\n",
1594 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1595 " FROM pg_trigger;\n",
1596
1597 /*
1598 * restriction here to avoid pinning the public namespace
1599 */
1600 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1601 " FROM pg_namespace "
1602 " WHERE nspname LIKE 'pg%';\n",
1603
1604 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1605 " FROM pg_ts_parser;\n",
1606 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1607 " FROM pg_ts_dict;\n",
1608 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1609 " FROM pg_ts_template;\n",
1610 "INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' "
1611 " FROM pg_ts_config;\n",
1612 "INSERT INTO pg_shdepend SELECT 0,0,0,0, tableoid,oid, 'p' "
1613 " FROM pg_authid;\n",
1614 NULL
1615 };
1616
1617 fputs(_("initializing dependencies ... "), stdout);
1618 fflush(stdout);
1619
1620 snprintf(cmd, sizeof(cmd),
1621 "\"%s\" %s template1 >%s",
1622 backend_exec, backend_options,
1623 DEVNULL);
1624
1625 PG_CMD_OPEN;
1626
1627 for (line = pg_depend_setup; *line != NULL; line++)
1628 PG_CMD_PUTS(*line);
1629
1630 PG_CMD_CLOSE;
1631
1632 check_ok();
1633 }
1634
1635 /*
1636 * set up system views
1637 */
1638 static void
1639 setup_sysviews(void)
1640 {
1641 PG_CMD_DECL;
1642 char **line;
1643 char **sysviews_setup;
1644
1645 fputs(_("creating system views ... "), stdout);
1646 fflush(stdout);
1647
1648 sysviews_setup = readfile(system_views_file);
1649
1650 /*
1651 * We use -j here to avoid backslashing stuff in system_views.sql
1652 */
1653 snprintf(cmd, sizeof(cmd),
1654 "\"%s\" %s -j template1 >%s",
1655 backend_exec, backend_options,
1656 DEVNULL);
1657
1658 PG_CMD_OPEN;
1659
1660 for (line = sysviews_setup; *line != NULL; line++)
1661 {
1662 PG_CMD_PUTS(*line);
1663 free(*line);
1664 }
1665
1666 PG_CMD_CLOSE;
1667
1668 free(sysviews_setup);
1669
1670 check_ok();
1671 }
1672
1673 /*
1674 * load description data
1675 */
1676 static void
1677 setup_description(void)
1678 {
1679 PG_CMD_DECL;
1680
1681 fputs(_("loading system objects' descriptions ... "), stdout);
1682 fflush(stdout);
1683
1684 snprintf(cmd, sizeof(cmd),
1685 "\"%s\" %s template1 >%s",
1686 backend_exec, backend_options,
1687 DEVNULL);
1688
1689 PG_CMD_OPEN;
1690
1691 PG_CMD_PUTS("CREATE TEMP TABLE tmp_pg_description ( "
1692 " objoid oid, "
1693 " classname name, "
1694 " objsubid int4, "
1695 " description text) WITHOUT OIDS;\n");
1696
1697 PG_CMD_PRINTF1("COPY tmp_pg_description FROM E'%s';\n",
1698 escape_quotes(desc_file));
1699
1700 PG_CMD_PUTS("INSERT INTO pg_description "
1701 " SELECT t.objoid, c.oid, t.objsubid, t.description "
1702 " FROM tmp_pg_description t, pg_class c "
1703 " WHERE c.relname = t.classname;\n");
1704
1705 PG_CMD_PUTS("CREATE TEMP TABLE tmp_pg_shdescription ( "
1706 " objoid oid, "
1707 " classname name, "
1708 " description text) WITHOUT OIDS;\n");
1709
1710 PG_CMD_PRINTF1("COPY tmp_pg_shdescription FROM E'%s';\n",
1711 escape_quotes(shdesc_file));
1712
1713 PG_CMD_PUTS("INSERT INTO pg_shdescription "
1714 " SELECT t.objoid, c.oid, t.description "
1715 " FROM tmp_pg_shdescription t, pg_class c "
1716 " WHERE c.relname = t.classname;\n");
1717
1718 PG_CMD_CLOSE;
1719
1720 check_ok();
1721 }
1722
1723 /*
1724 * load conversion functions
1725 */
1726 static void
1727 setup_conversion(void)
1728 {
1729 PG_CMD_DECL;
1730 char **line;
1731 char **conv_lines;
1732
1733 fputs(_("creating conversions ... "), stdout);
1734 fflush(stdout);
1735
1736 snprintf(cmd, sizeof(cmd),
1737 "\"%s\" %s template1 >%s",
1738 backend_exec, backend_options,
1739 DEVNULL);
1740
1741 PG_CMD_OPEN;
1742
1743 conv_lines = readfile(conversion_file);
1744 for (line = conv_lines; *line != NULL; line++)
1745 {
1746 if (strstr(*line, "DROP CONVERSION") != *line)
1747 PG_CMD_PUTS(*line);
1748 free(*line);
1749 }
1750
1751 free(conv_lines);
1752
1753 PG_CMD_CLOSE;
1754
1755 check_ok();
1756 }
1757
1758 /*
1759 * load extra dictionaries (Snowball stemmers)
1760 */
1761 static void
1762 setup_dictionary(void)
1763 {
1764 PG_CMD_DECL;
1765 char **line;
1766 char **conv_lines;
1767
1768 fputs(_("creating dictionaries ... "), stdout);
1769 fflush(stdout);
1770
1771 /*
1772 * We use -j here to avoid backslashing stuff
1773 */
1774 snprintf(cmd, sizeof(cmd),
1775 "\"%s\" %s -j template1 >%s",
1776 backend_exec, backend_options,
1777 DEVNULL);
1778
1779 PG_CMD_OPEN;
1780
1781 conv_lines = readfile(dictionary_file);
1782 for (line = conv_lines; *line != NULL; line++)
1783 {
1784 PG_CMD_PUTS(*line);
1785 free(*line);
1786 }
1787
1788 free(conv_lines);
1789
1790 PG_CMD_CLOSE;
1791
1792 check_ok();
1793 }
1794
1795 /*
1796 * Set up privileges
1797 *
1798 * We mark most system catalogs as world-readable. We don't currently have
1799 * to touch functions, languages, or databases, because their default
1800 * permissions are OK.
1801 *
1802 * Some objects may require different permissions by default, so we
1803 * make sure we don't overwrite privilege sets that have already been
1804 * set (NOT NULL).
1805 */
1806 static void
1807 setup_privileges(void)
1808 {
1809 PG_CMD_DECL;
1810 char **line;
1811 char **priv_lines;
1812 static char *privileges_setup[] = {
1813 "UPDATE pg_class "
1814 " SET relacl = E'{\"=r/\\\\\"$POSTGRES_SUPERUSERNAME\\\\\"\"}' "
1815 " WHERE relkind IN ('r', 'v', 'S') AND relacl IS NULL;\n",
1816 "GRANT USAGE ON SCHEMA pg_catalog TO PUBLIC;\n",
1817 "GRANT CREATE, USAGE ON SCHEMA public TO PUBLIC;\n",
1818 NULL
1819 };
1820
1821 fputs(_("setting privileges on built-in objects ... "), stdout);
1822 fflush(stdout);
1823
1824 snprintf(cmd, sizeof(cmd),
1825 "\"%s\" %s template1 >%s",
1826 backend_exec, backend_options,
1827 DEVNULL);
1828
1829 PG_CMD_OPEN;
1830
1831 priv_lines = replace_token(privileges_setup,
1832 "$POSTGRES_SUPERUSERNAME", username);
1833 for (line = priv_lines; *line != NULL; line++)
1834 PG_CMD_PUTS(*line);
1835
1836 PG_CMD_CLOSE;
1837
1838 check_ok();
1839 }
1840
1841 /*
1842 * extract the strange version of version required for information schema
1843 * (09.08.0007abc)
1844 */
1845 static void
1846 set_info_version(void)
1847 {
1848 char *letterversion;
1849 long major = 0,
1850 minor = 0,
1851 micro = 0;
1852 char *endptr;
1853 char *vstr = xstrdup(PG_VERSION);
1854 char *ptr;
1855
1856 ptr = vstr + (strlen(vstr) - 1);
1857 while (ptr != vstr && (*ptr < '0' || *ptr > '9'))
1858 ptr--;
1859 letterversion = ptr + 1;
1860 major = strtol(vstr, &endptr, 10);
1861 if (*endptr)
1862 minor = strtol(endptr + 1, &endptr, 10);
1863 if (*endptr)
1864 micro = strtol(endptr + 1, &endptr, 10);
1865 snprintf(infoversion, sizeof(infoversion), "%02ld.%02ld.%04ld%s",
1866 major, minor, micro, letterversion);
1867 }
1868
1869 /*
1870 * load info schema and populate from features file
1871 */
1872 static void
1873 setup_schema(void)
1874 {
1875 PG_CMD_DECL;
1876 char **line;
1877 char **lines;
1878
1879 fputs(_("creating information schema ... "), stdout);
1880 fflush(stdout);
1881
1882 lines = readfile(info_schema_file);
1883
1884 /*
1885 * We use -j here to avoid backslashing stuff in information_schema.sql
1886 */
1887 snprintf(cmd, sizeof(cmd),
1888 "\"%s\" %s -j template1 >%s",
1889 backend_exec, backend_options,
1890 DEVNULL);
1891
1892 PG_CMD_OPEN;
1893
1894 for (line = lines; *line != NULL; line++)
1895 {
1896 PG_CMD_PUTS(*line);
1897 free(*line);
1898 }
1899
1900 free(lines);
1901
1902 PG_CMD_CLOSE;
1903
1904 snprintf(cmd, sizeof(cmd),
1905 "\"%s\" %s template1 >%s",
1906 backend_exec, backend_options,
1907 DEVNULL);
1908
1909 PG_CMD_OPEN;
1910
1911 PG_CMD_PRINTF1("UPDATE information_schema.sql_implementation_info "
1912 " SET character_value = '%s' "
1913 " WHERE implementation_info_name = 'DBMS VERSION';\n",
1914 infoversion);
1915
1916 PG_CMD_PRINTF1("COPY information_schema.sql_features "
1917 " (feature_id, feature_name, sub_feature_id, "
1918 " sub_feature_name, is_supported, comments) "
1919 " FROM E'%s';\n",
1920 escape_quotes(features_file));
1921
1922 PG_CMD_CLOSE;
1923
1924 check_ok();
1925 }
1926
1927 /*
1928 * clean everything up in template1
1929 */
1930 static void
1931 vacuum_db(void)
1932 {
1933 PG_CMD_DECL;
1934
1935 fputs(_("vacuuming database template1 ... "), stdout);
1936 fflush(stdout);
1937
1938 snprintf(cmd, sizeof(cmd),
1939 "\"%s\" %s template1 >%s",
1940 backend_exec, backend_options,
1941 DEVNULL);
1942
1943 PG_CMD_OPEN;
1944
1945 PG_CMD_PUTS("ANALYZE;\nVACUUM FULL;\nVACUUM FREEZE;\n");
1946
1947 PG_CMD_CLOSE;
1948
1949 check_ok();
1950 }
1951
1952 /*
1953 * copy template1 to template0
1954 */
1955 static void
1956 make_template0(void)
1957 {
1958 PG_CMD_DECL;
1959 const char **line;
1960 static const char *template0_setup[] = {
1961 "CREATE DATABASE template0;\n",
1962 "UPDATE pg_database SET "
1963 " datistemplate = 't', "
1964 " datallowconn = 'f' "
1965 " WHERE datname = 'template0';\n",
1966
1967 /*
1968 * We use the OID of template0 to determine lastsysoid
1969 */
1970 "UPDATE pg_database SET datlastsysoid = "
1971 " (SELECT oid FROM pg_database "
1972 " WHERE datname = 'template0');\n",
1973
1974 /*
1975 * Explicitly revoke public create-schema and create-temp-table
1976 * privileges in template1 and template0; else the latter would be on
1977 * by default
1978 */
1979 "REVOKE CREATE,TEMPORARY ON DATABASE template1 FROM public;\n",
1980 "REVOKE CREATE,TEMPORARY ON DATABASE template0 FROM public;\n",
1981
1982 /*
1983 * Finally vacuum to clean up dead rows in pg_database
1984 */
1985 "VACUUM FULL pg_database;\n",
1986 NULL
1987 };
1988
1989 fputs(_("copying template1 to template0 ... "), stdout);
1990 fflush(stdout);
1991
1992 snprintf(cmd, sizeof(cmd),
1993 "\"%s\" %s template1 >%s",
1994 backend_exec, backend_options,
1995 DEVNULL);
1996
1997 PG_CMD_OPEN;
1998
1999 for (line = template0_setup; *line; line++)
2000 PG_CMD_PUTS(*line);
2001
2002 PG_CMD_CLOSE;
2003
2004 check_ok();
2005 }
2006
2007 /*
2008 * copy template1 to postgres
2009 */
2010 static void
2011 make_postgres(void)
2012 {
2013 PG_CMD_DECL;
2014 const char **line;
2015 static const char *postgres_setup[] = {
2016 "CREATE DATABASE postgres;\n",
2017 NULL
2018 };
2019
2020 fputs(_("copying template1 to postgres ... "), stdout);
2021 fflush(stdout);
2022
2023 snprintf(cmd, sizeof(cmd),
2024 "\"%s\" %s template1 >%s",
2025 backend_exec, backend_options,
2026 DEVNULL);
2027
2028 PG_CMD_OPEN;
2029
2030 for (line = postgres_setup; *line; line++)
2031 PG_CMD_PUTS(*line);
2032
2033 PG_CMD_CLOSE;
2034
2035 check_ok();
2036 }
2037
2038
2039 /*
2040 * signal handler in case we are interrupted.
2041 *
2042 * The Windows runtime docs at
2043 * http://msdn.microsoft.com/library/en-us/vclib/html/_crt_signal.asp
2044 * specifically forbid a number of things being done from a signal handler,
2045 * including IO, memory allocation and system calls, and only allow jmpbuf
2046 * if you are handling SIGFPE.
2047 *
2048 * I avoided doing the forbidden things by setting a flag instead of calling
2049 * exit_nicely() directly.
2050 *
2051 * Also note the behaviour of Windows with SIGINT, which says this:
2052 * Note SIGINT is not supported for any Win32 application, including
2053 * Windows 98/Me and Windows NT/2000/XP. When a CTRL+C interrupt occurs,
2054 * Win32 operating systems generate a new thread to specifically handle
2055 * that interrupt. This can cause a single-thread application such as UNIX,
2056 * to become multithreaded, resulting in unexpected behavior.
2057 *
2058 * I have no idea how to handle this. (Strange they call UNIX an application!)
2059 * So this will need some testing on Windows.
2060 */
2061 static void
2062 trapsig(int signum)
2063 {
2064 /* handle systems that reset the handler, like Windows (grr) */
2065 pqsignal(signum, trapsig);
2066 caught_signal = true;
2067 }
2068
2069 /*
2070 * call exit_nicely() if we got a signal, or else output "ok".
2071 */
2072 static void
2073 check_ok(void)
2074 {
2075 if (caught_signal)
2076 {
2077 printf(_("caught signal\n"));
2078 fflush(stdout);
2079 exit_nicely();
2080 }
2081 else if (output_failed)
2082 {
2083 printf(_("could not write to child process: %s\n"),
2084 strerror(output_errno));
2085 fflush(stdout);
2086 exit_nicely();
2087 }
2088 else
2089 {
2090 /* all seems well */
2091 printf(_("ok\n"));
2092 fflush(stdout);
2093 }
2094 }
2095
2096 /*
2097 * Escape (by doubling) any single quotes or backslashes in given string
2098 *
2099 * Note: this is used to process both postgresql.conf entries and SQL
2100 * string literals. Since postgresql.conf strings are defined to treat
2101 * backslashes as escapes, we have to double backslashes here. Hence,
2102 * when using this for a SQL string literal, use E'' syntax.
2103 *
2104 * We do not need to worry about encoding considerations because all
2105 * valid backend encodings are ASCII-safe.
2106 */
2107 static char *
2108 escape_quotes(const char *src)
2109 {
2110 int len = strlen(src),
2111 i,
2112 j;
2113 char *result = pg_malloc(len * 2 + 1);
2114
2115 for (i = 0, j = 0; i < len; i++)
2116 {
2117 if (SQL_STR_DOUBLE(src[i], true))
2118 result[j++] = src[i];
2119 result[j++] = src[i];
2120 }
2121 result[j] = '\0';
2122 return result;
2123 }
2124
2125 /* Hack to suppress a warning about %x from some versions of gcc */
2126 static inline size_t
2127 my_strftime(char *s, size_t max, const char *fmt, const struct tm * tm)
2128 {
2129 return strftime(s, max, fmt, tm);
2130 }
2131
2132 /*
2133 * Determine likely date order from locale
2134 */
2135 static int
2136 locale_date_order(const char *locale)
2137 {
2138 struct tm testtime;
2139 char buf[128];
2140 char *posD;
2141 char *posM;
2142 char *posY;
2143 char *save;
2144 size_t res;
2145 int result;
2146
2147 result = DATEORDER_MDY; /* default */
2148
2149 save = setlocale(LC_TIME, NULL);
2150 if (!save)
2151 return result;
2152 save = xstrdup(save);
2153
2154 setlocale(LC_TIME, locale);
2155
2156 memset(&testtime, 0, sizeof(testtime));
2157 testtime.tm_mday = 22;
2158 testtime.tm_mon = 10; /* November, should come out as "11" */
2159 testtime.tm_year = 133; /* 2033 */
2160
2161 res = my_strftime(buf, sizeof(buf), "%x", &testtime);
2162
2163 setlocale(LC_TIME, save);
2164 free(save);
2165
2166 if (res == 0)
2167 return result;
2168
2169 posM = strstr(buf, "11");
2170 posD = strstr(buf, "22");
2171 posY = strstr(buf, "33");
2172
2173 if (!posM || !posD || !posY)
2174 return result;
2175
2176 if (posY < posM && posM < posD)
2177 result = DATEORDER_YMD;
2178 else if (posD < posM)
2179 result = DATEORDER_DMY;
2180 else
2181 result = DATEORDER_MDY;
2182
2183 return result;
2184 }
2185
2186 /*
2187 * check if given string is a valid locale specifier
2188 *
2189 * this should match the backend check_locale() function
2190 */
2191 static bool
2192 check_locale_name(const char *locale)
2193 {
2194 bool ret;
2195 int category = LC_CTYPE;
2196 char *save;
2197
2198 save = setlocale(category, NULL);
2199 if (!save)
2200 return false; /* should not happen; */
2201
2202 save = xstrdup(save);
2203
2204 ret = (setlocale(category, locale) != NULL);
2205
2206 setlocale(category, save);
2207 free(save);
2208
2209 /* should we exit here? */
2210 if (!ret)
2211 fprintf(stderr, _("%s: invalid locale name \"%s\"\n"), progname, locale);
2212
2213 return ret;
2214 }
2215
2216 /*
2217 * check if the chosen encoding matches the encoding required by the locale
2218 *
2219 * this should match the similar check in the backend createdb() function
2220 */
2221 static bool
2222 check_locale_encoding(const char *locale, int user_enc)
2223 {
2224 int locale_enc;
2225
2226 locale_enc = pg_get_encoding_from_locale(locale);
2227
2228 /* We allow selection of SQL_ASCII --- see notes in createdb() */
2229 if (!(locale_enc == user_enc ||
2230 locale_enc == PG_SQL_ASCII ||
2231 user_enc == PG_SQL_ASCII
2232 #ifdef WIN32
2233
2234 /*
2235 * On win32, if the encoding chosen is UTF8, all locales are OK (assuming
2236 * the actual locale name passed the checks above). This is because UTF8
2237 * is a pseudo-codepage, that we convert to UTF16 before doing any
2238 * operations on, and UTF16 supports all locales.
2239 */
2240 || user_enc == PG_UTF8
2241 #endif
2242 ))
2243 {
2244 fprintf(stderr, _("%s: encoding mismatch\n"), progname);
2245 fprintf(stderr,
2246 _("The encoding you selected (%s) and the encoding that the\n"
2247 "selected locale uses (%s) do not match. This would lead to\n"
2248 "misbehavior in various character string processing functions.\n"
2249 "Rerun %s and either do not specify an encoding explicitly,\n"
2250 "or choose a matching combination.\n"),
2251 pg_encoding_to_char(user_enc),
2252 pg_encoding_to_char(locale_enc),
2253 progname);
2254 return false;
2255 }
2256 return true;
2257 }
2258
2259
2260 /*
2261 * set up the locale variables
2262 *
2263 * assumes we have called setlocale(LC_ALL,"")
2264 */
2265 static void
2266 setlocales(void)
2267 {
2268 /* set empty lc_* values to locale config if set */
2269
2270 if (strlen(locale) > 0)
2271 {
2272 if (strlen(lc_ctype) == 0)
2273 lc_ctype = locale;
2274 if (strlen(lc_collate) == 0)
2275 lc_collate = locale;
2276 if (strlen(lc_numeric) == 0)
2277 lc_numeric = locale;
2278 if (strlen(lc_time) == 0)
2279 lc_time = locale;
2280 if (strlen(lc_monetary) == 0)
2281 lc_monetary = locale;
2282 if (strlen(lc_messages) == 0)
2283 lc_messages = locale;
2284 }
2285
2286 /*
2287 * override absent/invalid config settings from initdb's locale settings
2288 */
2289
2290 if (strlen(lc_ctype) == 0 || !check_locale_name(lc_ctype))
2291 lc_ctype = xstrdup(setlocale(LC_CTYPE, NULL));
2292 if (strlen(lc_collate) == 0 || !check_locale_name(lc_collate))
2293 lc_collate = xstrdup(setlocale(LC_COLLATE, NULL));
2294 if (strlen(lc_numeric) == 0 || !check_locale_name(lc_numeric))
2295 lc_numeric = xstrdup(setlocale(LC_NUMERIC, NULL));
2296 if (strlen(lc_time) == 0 || !check_locale_name(lc_time))
2297 lc_time = xstrdup(setlocale(LC_TIME, NULL));
2298 if (strlen(lc_monetary) == 0 || !check_locale_name(lc_monetary))
2299 lc_monetary = xstrdup(setlocale(LC_MONETARY, NULL));
2300 if (strlen(lc_messages) == 0 || !check_locale_name(lc_messages))
2301 #if defined(LC_MESSAGES) && !defined(WIN32)
2302 {
2303 /* when available get the current locale setting */
2304 lc_messages = xstrdup(setlocale(LC_MESSAGES, NULL));
2305 }
2306 #else
2307 {
2308 /* when not available, get the CTYPE setting */
2309 lc_messages = xstrdup(setlocale(LC_CTYPE, NULL));
2310 }
2311 #endif
2312
2313 }
2314
2315 #ifdef WIN32
2316 typedef BOOL (WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
2317
2318 #define DISABLE_MAX_PRIVILEGE 0x1
2319
2320 /*
2321 * Create a restricted token and execute the specified process with it.
2322 *
2323 * Returns 0 on failure, non-zero on success, same as CreateProcess().
2324 *
2325 * On NT4, or any other system not containing the required functions, will
2326 * NOT execute anything.
2327 */
2328 static int
2329 CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo)
2330 {
2331 BOOL b;
2332 STARTUPINFO si;
2333 HANDLE origToken;
2334 HANDLE restrictedToken;
2335 SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
2336 SID_AND_ATTRIBUTES dropSids[2];
2337 __CreateRestrictedToken _CreateRestrictedToken = NULL;
2338 HANDLE Advapi32Handle;
2339
2340 ZeroMemory(&si, sizeof(si));
2341 si.cb = sizeof(si);
2342
2343 Advapi32Handle = LoadLibrary("ADVAPI32.DLL");
2344 if (Advapi32Handle != NULL)
2345 {
2346 _CreateRestrictedToken = (__CreateRestrictedToken) GetProcAddress(Advapi32Handle, "CreateRestrictedToken");
2347 }
2348
2349 if (_CreateRestrictedToken == NULL)
2350 {
2351 fprintf(stderr, "WARNING: cannot create restricted tokens on this platform\n");
2352 if (Advapi32Handle != NULL)
2353 FreeLibrary(Advapi32Handle);
2354 return 0;
2355 }
2356
2357 /* Open the current token to use as a base for the restricted one */
2358 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &origToken))
2359 {
2360 fprintf(stderr, "Failed to open process token: %lu\n", GetLastError());
2361 return 0;
2362 }
2363
2364 /* Allocate list of SIDs to remove */
2365 ZeroMemory(&dropSids, sizeof(dropSids));
2366 if (!AllocateAndInitializeSid(&NtAuthority, 2,
2367 SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0,
2368 0, &dropSids[0].Sid) ||
2369 !AllocateAndInitializeSid(&NtAuthority, 2,
2370 SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_POWER_USERS, 0, 0, 0, 0, 0,
2371 0, &dropSids[1].Sid))
2372 {
2373 fprintf(stderr, "Failed to allocate SIDs: %lu\n", GetLastError());
2374 return 0;
2375 }
2376
2377 b = _CreateRestrictedToken(origToken,
2378 DISABLE_MAX_PRIVILEGE,
2379 sizeof(dropSids) / sizeof(dropSids[0]),
2380 dropSids,
2381 0, NULL,
2382 0, NULL,
2383 &restrictedToken);
2384
2385 FreeSid(dropSids[1].Sid);
2386 FreeSid(dropSids[0].Sid);
2387 CloseHandle(origToken);
2388 FreeLibrary(Advapi32Handle);
2389
2390 if (!b)
2391 {
2392 fprintf(stderr, "Failed to create restricted token: %lu\n", GetLastError());
2393 return 0;
2394 }
2395
2396 if (!CreateProcessAsUser(restrictedToken,
2397 NULL,
2398 cmd,
2399 NULL,
2400 NULL,
2401 TRUE,
2402 CREATE_SUSPENDED,
2403 NULL,
2404 NULL,
2405 &si,
2406 processInfo))
2407
2408 {
2409 fprintf(stderr, "CreateProcessAsUser failed: %lu\n", GetLastError());
2410 return 0;
2411 }
2412
2413 #ifndef __CYGWIN__
2414 AddUserToDacl(processInfo->hProcess);
2415 #endif
2416
2417 return ResumeThread(processInfo->hThread);
2418 }
2419 #endif
2420
2421 /*
2422 * print help text
2423 */
2424 static void
2425 usage(const char *progname)
2426 {
2427 printf(_("%s initializes a PostgreSQL database cluster.\n\n"), progname);
2428 printf(_("Usage:\n"));
2429 printf(_(" %s [OPTION]... [DATADIR]\n"), progname);
2430 printf(_("\nOptions:\n"));
2431 printf(_(" -A, --auth=METHOD default authentication method for local connections\n"));
2432 printf(_(" [-D, --pgdata=]DATADIR location for this database cluster\n"));
2433 printf(_(" -E, --encoding=ENCODING set default encoding for new databases\n"));
2434 printf(_(" --locale=LOCALE set default locale for new databases\n"));
2435 printf(_(" --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
2436 " --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n"
2437 " set default locale in the respective category for\n"
2438 " new databases (default taken from environment)\n"));
2439 printf(_(" --no-locale equivalent to --locale=C\n"));
2440 printf(_(" --pwfile=FILE read password for the new superuser from file\n"));
2441 printf(_(" -T, --text-search-config=CFG\n"
2442 " default text search configuration\n"));
2443 printf(_(" -U, --username=NAME database superuser name\n"));
2444 printf(_(" -W, --pwprompt prompt for a password for the new superuser\n"));
2445 printf(_(" -X, --xlogdir=XLOGDIR location for the transaction log directory\n"));
2446 printf(_("\nLess commonly used options:\n"));
2447 printf(_(" -d, --debug generate lots of debugging output\n"));
2448 printf(_(" -L DIRECTORY where to find the input files\n"));
2449 printf(_(" -n, --noclean do not clean up after errors\n"));
2450 printf(_(" -s, --show show internal settings\n"));
2451 printf(_("\nOther options:\n"));
2452 printf(_(" -?, --help show this help, then exit\n"));
2453 printf(_(" -V, --version output version information, then exit\n"));
2454 printf(_("\nIf the data directory is not specified, the environment variable PGDATA\n"
2455 "is used.\n"));
2456 printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
2457 }
2458
2459 int
2460 main(int argc, char *argv[])
2461 {
2462 /*
2463 * options with no short version return a low integer, the rest return
2464 * their short version value
2465 */
2466 static struct option long_options[] = {
2467 {"pgdata", required_argument, NULL, 'D'},
2468 {"encoding", required_argument, NULL, 'E'},
2469 {"locale", required_argument, NULL, 1},
2470 {"lc-collate", required_argument, NULL, 2},
2471 {"lc-ctype", required_argument, NULL, 3},
2472 {"lc-monetary", required_argument, NULL, 4},
2473 {"lc-numeric", required_argument, NULL, 5},
2474 {"lc-time", required_argument, NULL, 6},
2475 {"lc-messages", required_argument, NULL, 7},
2476 {"no-locale", no_argument, NULL, 8},
2477 {"text-search-config", required_argument, NULL, 'T'},
2478 {"auth", required_argument, NULL, 'A'},
2479 {"pwprompt", no_argument, NULL, 'W'},
2480 {"pwfile", required_argument, NULL, 9},
2481 {"username", required_argument, NULL, 'U'},
2482 {"help", no_argument, NULL, '?'},
2483 {"version", no_argument, NULL, 'V'},
2484 {"debug", no_argument, NULL, 'd'},
2485 {"show", no_argument, NULL, 's'},
2486 {"noclean", no_argument, NULL, 'n'},
2487 {"xlogdir", required_argument, NULL, 'X'},
2488 {NULL, 0, NULL, 0}
2489 };
2490
2491 int c,
2492 i,
2493 ret;
2494 int option_index;
2495 char *short_version;
2496 char *effective_user;
2497 char *pgdenv; /* PGDATA value gotten from and sent to
2498 * environment */
2499 char bin_dir[MAXPGPATH];
2500 char *pg_data_native;
2501 int user_enc;
2502
2503 #ifdef WIN32
2504 char *restrict_env;
2505 #endif
2506 static const char *subdirs[] = {
2507 "global",
2508 "pg_xlog",
2509 "pg_xlog/archive_status",
2510 "pg_clog",
2511 "pg_subtrans",
2512 "pg_twophase",
2513 "pg_multixact/members",
2514 "pg_multixact/offsets",
2515 "base",
2516 "base/1",
2517 "pg_tblspc",
2518 "pg_stat_tmp"
2519 };
2520
2521 progname = get_progname(argv[0]);
2522 set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("initdb"));
2523
2524 if (argc > 1)
2525 {
2526 if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2527 {
2528 usage(progname);
2529 exit(0);
2530 }
2531 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2532 {
2533 puts("initdb (PostgreSQL) " PG_VERSION);
2534 exit(0);
2535 }
2536 }
2537
2538 /* process command-line options */
2539
2540 while ((c = getopt_long(argc, argv, "dD:E:L:nU:WA:sT:X:", long_options, &option_index)) != -1)
2541 {
2542 switch (c)
2543 {
2544 case 'A':
2545 authmethod = xstrdup(optarg);
2546 break;
2547 case 'D':
2548 pg_data = xstrdup(optarg);
2549 break;
2550 case 'E':
2551 encoding = xstrdup(optarg);
2552 break;
2553 case 'W':
2554 pwprompt = true;
2555 break;
2556 case 'U':
2557 username = xstrdup(optarg);
2558 break;
2559 case 'd':
2560 debug = true;
2561 printf(_("Running in debug mode.\n"));
2562 break;
2563 case 'n':
2564 noclean = true;
2565 printf(_("Running in noclean mode. Mistakes will not be cleaned up.\n"));
2566 break;
2567 case 'L':
2568 share_path = xstrdup(optarg);
2569 break;
2570 case 1:
2571 locale = xstrdup(optarg);
2572 break;
2573 case 2:
2574 lc_collate = xstrdup(optarg);
2575 break;
2576 case 3:
2577 lc_ctype = xstrdup(optarg);
2578 break;
2579 case 4:
2580 lc_monetary = xstrdup(optarg);
2581 break;
2582 case 5:
2583 lc_numeric = xstrdup(optarg);
2584 break;
2585 case 6:
2586 lc_time = xstrdup(optarg);
2587 break;
2588 case 7:
2589 lc_messages = xstrdup(optarg);
2590 break;
2591 case 8:
2592 locale = "C";
2593 break;
2594 case 9:
2595 pwfilename = xstrdup(optarg);
2596 break;
2597 case 's':
2598 show_setting = true;
2599 break;
2600 case 'T':
2601 default_text_search_config = xstrdup(optarg);
2602 break;
2603 case 'X':
2604 xlog_dir = xstrdup(optarg);
2605 break;
2606 default:
2607 /* getopt_long already emitted a complaint */
2608 fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
2609 progname);
2610 exit(1);
2611 }
2612 }
2613
2614
2615 /* Non-option argument specifies data directory */
2616 if (optind < argc)
2617 {
2618 pg_data = xstrdup(argv[optind]);
2619 optind++;
2620 }
2621
2622 if (optind < argc)
2623 {
2624 fprintf(stderr, _("%s: too many command-line arguments (first is \"%s\")\n"),
2625 progname, argv[optind + 1]);
2626 fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
2627 progname);
2628 exit(1);
2629 }
2630
2631 if (pwprompt && pwfilename)
2632 {
2633 fprintf(stderr, _("%s: password prompt and password file cannot be specified together\n"), progname);
2634 exit(1);
2635 }
2636
2637 if (authmethod == NULL || !strlen(authmethod))
2638 {
2639 authwarning = _("\nWARNING: enabling \"trust\" authentication for local connections\n"
2640 "You can change this by editing pg_hba.conf or using the -A option the\n"
2641 "next time you run initdb.\n");
2642 authmethod = "trust";
2643 }
2644
2645 if (strcmp(authmethod, "md5") &&
2646 strcmp(authmethod, "ident") &&
2647 strncmp(authmethod, "ident ", 6) && /* ident with space = param */
2648 strcmp(authmethod, "trust") &&
2649 #ifdef USE_PAM
2650 strcmp(authmethod, "pam") &&
2651 strncmp(authmethod, "pam ", 4) && /* pam with space = param */
2652 #endif
2653 strcmp(authmethod, "crypt") &&
2654 strcmp(authmethod, "password")
2655 )
2656
2657 /*
2658 * Kerberos methods not listed because they are not supported over
2659 * local connections and are rejected in hba.c
2660 */
2661 {
2662 fprintf(stderr, _("%s: unrecognized authentication method \"%s\"\n"),
2663 progname, authmethod);
2664 exit(1);
2665 }
2666
2667 if ((!strcmp(authmethod, "md5") ||
2668 !strcmp(authmethod, "crypt") ||
2669 !strcmp(authmethod, "password")) &&
2670 !(pwprompt || pwfilename))
2671 {
2672 fprintf(stderr, _("%s: must specify a password for the superuser to enable %s authentication\n"), progname, authmethod);
2673 exit(1);
2674 }
2675
2676 if (strlen(pg_data) == 0)
2677 {
2678 pgdenv = getenv("PGDATA");
2679 if (pgdenv && strlen(pgdenv))
2680 {
2681 /* PGDATA found */
2682 pg_data = xstrdup(pgdenv);
2683 }
2684 else
2685 {
2686 fprintf(stderr,
2687 _("%s: no data directory specified\n"
2688 "You must identify the directory where the data for this database system\n"
2689 "will reside. Do this with either the invocation option -D or the\n"
2690 "environment variable PGDATA.\n"),
2691 progname);
2692 exit(1);
2693 }
2694 }
2695
2696 pg_data_native = pg_data;
2697 canonicalize_path(pg_data);
2698
2699 #ifdef WIN32
2700
2701 /*
2702 * Before we execute another program, make sure that we are running with a
2703 * restricted token. If not, re-execute ourselves with one.
2704 */
2705
2706 if ((restrict_env = getenv("PG_RESTRICT_EXEC")) == NULL
2707 || strcmp(restrict_env, "1") != 0)
2708 {
2709 PROCESS_INFORMATION pi;
2710 char *cmdline;
2711
2712 ZeroMemory(&pi, sizeof(pi));
2713
2714 cmdline = xstrdup(GetCommandLine());
2715
2716 putenv("PG_RESTRICT_EXEC=1");
2717
2718 if (!CreateRestrictedProcess(cmdline, &pi))
2719 {
2720 fprintf(stderr, "Failed to re-exec with restricted token: %lu.\n", GetLastError());
2721 }
2722 else
2723 {
2724 /*
2725 * Successfully re-execed. Now wait for child process to capture
2726 * exitcode.
2727 */
2728 DWORD x;
2729
2730 CloseHandle(pi.hThread);
2731 WaitForSingleObject(pi.hProcess, INFINITE);
2732
2733 if (!GetExitCodeProcess(pi.hProcess, &x))
2734 {
2735 fprintf(stderr, "Failed to get exit code from subprocess: %lu\n", GetLastError());
2736 exit(1);
2737 }
2738 exit(x);
2739 }
2740 }
2741 #endif
2742
2743 /*
2744 * we have to set PGDATA for postgres rather than pass it on the command
2745 * line to avoid dumb quoting problems on Windows, and we would especially
2746 * need quotes otherwise on Windows because paths there are most likely to
2747 * have embedded spaces.
2748 */
2749 pgdenv = pg_malloc(8 + strlen(pg_data));
2750 sprintf(pgdenv, "PGDATA=%s", pg_data);
2751 putenv(pgdenv);
2752
2753 if ((ret = find_other_exec(argv[0], "postgres", PG_BACKEND_VERSIONSTR,
2754 backend_exec)) < 0)
2755 {
2756 char full_path[MAXPGPATH];
2757
2758 if (find_my_exec(argv[0], full_path) < 0)
2759 strlcpy(full_path, progname, sizeof(full_path));
2760
2761 if (ret == -1)
2762 fprintf(stderr,
2763 _("The program \"postgres\" is needed by %s "
2764 "but was not found in the\n"
2765 "same directory as \"%s\".\n"
2766 "Check your installation.\n"),
2767 progname, full_path);
2768 else
2769 fprintf(stderr,
2770 _("The program \"postgres\" was found by \"%s\"\n"
2771 "but was not the same version as %s.\n"
2772 "Check your installation.\n"),
2773 full_path, progname);
2774 exit(1);
2775 }
2776
2777 /* store binary directory */
2778 strcpy(bin_path, backend_exec);
2779 *last_dir_separator(bin_path) = '\0';
2780 canonicalize_path(bin_path);
2781
2782 if (!share_path)
2783 {
2784 share_path = pg_malloc(MAXPGPATH);
2785 get_share_path(backend_exec, share_path);
2786 }
2787 else if (!is_absolute_path(share_path))
2788 {
2789 fprintf(stderr, _("%s: input file location must be an absolute path\n"), progname);
2790 exit(1);
2791 }
2792
2793 canonicalize_path(share_path);
2794
2795 if ((short_version = get_short_version()) == NULL)
2796 {
2797 fprintf(stderr, _("%s: could not determine valid short version string\n"), progname);
2798 exit(1);
2799 }
2800
2801 effective_user = get_id();
2802 if (strlen(username) == 0)
2803 username = effective_user;
2804
2805 set_input(&bki_file, "postgres.bki");
2806 set_input(&desc_file, "postgres.description");
2807 set_input(&shdesc_file, "postgres.shdescription");
2808 set_input(&hba_file, "pg_hba.conf.sample");
2809 set_input(&ident_file, "pg_ident.conf.sample");
2810 set_input(&conf_file, "postgresql.conf.sample");
2811 set_input(&conversion_file, "conversion_create.sql");
2812 set_input(&dictionary_file, "snowball_create.sql");
2813 set_input(&info_schema_file, "information_schema.sql");
2814 set_input(&features_file, "sql_features.txt");
2815 set_input(&system_views_file, "system_views.sql");
2816
2817 set_info_version();
2818
2819 if (show_setting || debug)
2820 {
2821 fprintf(stderr,
2822 "VERSION=%s\n"
2823 "PGDATA=%s\nshare_path=%s\nPGPATH=%s\n"
2824 "POSTGRES_SUPERUSERNAME=%s\nPOSTGRES_BKI=%s\n"
2825 "POSTGRES_DESCR=%s\nPOSTGRES_SHDESCR=%s\n"
2826 "POSTGRESQL_CONF_SAMPLE=%s\n"
2827 "PG_HBA_SAMPLE=%s\nPG_IDENT_SAMPLE=%s\n",
2828 PG_VERSION,
2829 pg_data, share_path, bin_path,
2830 username, bki_file,
2831 desc_file, shdesc_file,
2832 conf_file,
2833 hba_file, ident_file);
2834 if (show_setting)
2835 exit(0);
2836 }
2837
2838 check_input(bki_file);
2839 check_input(desc_file);
2840 check_input(shdesc_file);
2841 check_input(hba_file);
2842 check_input(ident_file);
2843 check_input(conf_file);
2844 check_input(conversion_file);
2845 check_input(dictionary_file);
2846 check_input(info_schema_file);
2847 check_input(features_file);
2848 check_input(system_views_file);
2849
2850 setlocales();
2851
2852 printf(_("The files belonging to this database system will be owned "
2853 "by user \"%s\".\n"
2854 "This user must also own the server process.\n\n"),
2855 effective_user);
2856
2857 if (strcmp(lc_ctype, lc_collate) == 0 &&
2858 strcmp(lc_ctype, lc_time) == 0 &&
2859 strcmp(lc_ctype, lc_numeric) == 0 &&
2860 strcmp(lc_ctype, lc_monetary) == 0 &&
2861 strcmp(lc_ctype, lc_messages) == 0)
2862 printf(_("The database cluster will be initialized with locale %s.\n"), lc_ctype);
2863 else
2864 {
2865 printf(_("The database cluster will be initialized with locales\n"
2866 " COLLATE: %s\n"
2867 " CTYPE: %s\n"
2868 " MESSAGES: %s\n"
2869 " MONETARY: %s\n"
2870 " NUMERIC: %s\n"
2871 " TIME: %s\n"),
2872 lc_collate,
2873 lc_ctype,
2874 lc_messages,
2875 lc_monetary,
2876 lc_numeric,
2877 lc_time);
2878 }
2879
2880 if (strlen(encoding) == 0)
2881 {
2882 int ctype_enc;
2883
2884 ctype_enc = pg_get_encoding_from_locale(lc_ctype);
2885
2886 if (ctype_enc == PG_SQL_ASCII &&
2887 !(pg_strcasecmp(lc_ctype, "C") == 0 ||
2888 pg_strcasecmp(lc_ctype, "POSIX") == 0))
2889 {
2890 /* Hmm, couldn't recognize the locale's codeset */
2891 fprintf(stderr, _("%s: could not find suitable encoding for locale %s\n"),
2892 progname, lc_ctype);
2893 fprintf(stderr, _("Rerun %s with the -E option.\n"), progname);
2894 fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
2895 progname);
2896 exit(1);
2897 }
2898 else if (!pg_valid_server_encoding_id(ctype_enc))
2899 {
2900 /* We recognized it, but it's not a legal server encoding */
2901 fprintf(stderr,
2902 _("%s: locale %s requires unsupported encoding %s\n"),
2903 progname, lc_ctype, pg_encoding_to_char(ctype_enc));
2904 fprintf(stderr,
2905 _("Encoding %s is not allowed as a server-side encoding.\n"
2906 "Rerun %s with a different locale selection.\n"),
2907 pg_encoding_to_char(ctype_enc), progname);
2908 exit(1);
2909 }
2910 else
2911 {
2912 encodingid = encodingid_to_string(ctype_enc);
2913 printf(_("The default database encoding has accordingly been set to %s.\n"),
2914 pg_encoding_to_char(ctype_enc));
2915 }
2916 }
2917 else
2918 encodingid = get_encoding_id(encoding);
2919
2920 user_enc = atoi(encodingid);
2921 if (!check_locale_encoding(lc_ctype, user_enc) ||
2922 !check_locale_encoding(lc_collate, user_enc))
2923 exit(1); /* check_locale_encoding printed the error */
2924
2925 if (strlen(default_text_search_config) == 0)
2926 {
2927 default_text_search_config = find_matching_ts_config(lc_ctype);
2928 if (default_text_search_config == NULL)
2929 {
2930 printf(_("%s: could not find suitable text search configuration for locale %s\n"),
2931 progname, lc_ctype);
2932 default_text_search_config = "simple";
2933 }
2934 }
2935 else
2936 {
2937 const char *checkmatch = find_matching_ts_config(lc_ctype);
2938
2939 if (checkmatch == NULL)
2940 {
2941 printf(_("%s: warning: suitable text search configuration for locale %s is unknown\n"),
2942 progname, lc_ctype);
2943 }
2944 else if (strcmp(checkmatch, default_text_search_config) != 0)
2945 {
2946 printf(_("%s: warning: specified text search configuration \"%s\" might not match locale %s\n"),
2947 progname, default_text_search_config, lc_ctype);
2948 }
2949 }
2950
2951 printf(_("The default text search configuration will be set to \"%s\".\n"),
2952 default_text_search_config);
2953
2954 printf("\n");
2955
2956 umask(077);
2957
2958 /*
2959 * now we are starting to do real work, trap signals so we can clean up
2960 */
2961
2962 /* some of these are not valid on Windows */
2963 #ifdef SIGHUP
2964 pqsignal(SIGHUP, trapsig);
2965 #endif
2966 #ifdef SIGINT
2967 pqsignal(SIGINT, trapsig);
2968 #endif
2969 #ifdef SIGQUIT
2970 pqsignal(SIGQUIT, trapsig);
2971 #endif
2972 #ifdef SIGTERM
2973 pqsignal(SIGTERM, trapsig);
2974 #endif
2975
2976 /* Ignore SIGPIPE when writing to backend, so we can clean up */
2977 #ifdef SIGPIPE
2978 pqsignal(SIGPIPE, SIG_IGN);
2979 #endif
2980
2981 switch (check_data_dir(pg_data))
2982 {
2983 case 0:
2984 /* PGDATA not there, must create it */
2985 printf(_("creating directory %s ... "),
2986 pg_data);
2987 fflush(stdout);
2988
2989 if (!mkdatadir(NULL))
2990 exit_nicely();
2991 else
2992 check_ok();
2993
2994 made_new_pgdata = true;
2995 break;
2996
2997 case 1:
2998 /* Present but empty, fix permissions and use it */
2999 printf(_("fixing permissions on existing directory %s ... "),
3000 pg_data);
3001 fflush(stdout);
3002
3003 if (chmod(pg_data, 0700) != 0)
3004 {
3005 fprintf(stderr, _("%s: could not change permissions of directory \"%s\": %s\n"),
3006 progname, pg_data, strerror(errno));
3007 exit_nicely();
3008 }
3009 else
3010 check_ok();
3011
3012 found_existing_pgdata = true;
3013 break;
3014
3015 case 2:
3016 /* Present and not empty */
3017 fprintf(stderr,
3018 _("%s: directory \"%s\" exists but is not empty\n"),
3019 progname, pg_data);
3020 fprintf(stderr,
3021 _("If you want to create a new database system, either remove or empty\n"
3022 "the directory \"%s\" or run %s\n"
3023 "with an argument other than \"%s\".\n"),
3024 pg_data, progname, pg_data);
3025 exit(1); /* no further message needed */
3026
3027 default:
3028 /* Trouble accessing directory */
3029 fprintf(stderr, _("%s: could not access directory \"%s\": %s\n"),
3030 progname, pg_data, strerror(errno));
3031 exit_nicely();
3032 }
3033
3034 /* Create transaction log symlink, if required */
3035 if (strcmp(xlog_dir, "") != 0)
3036 {
3037 char *linkloc;
3038
3039 /* clean up xlog directory name, check it's absolute */
3040 canonicalize_path(xlog_dir);
3041 if (!is_absolute_path(xlog_dir))
3042 {
3043 fprintf(stderr, _("%s: transaction log directory location must be an absolute path\n"), progname);
3044 exit_nicely();
3045 }
3046
3047 /* check if the specified xlog directory is empty */
3048 switch (check_data_dir(xlog_dir))
3049 {
3050 case 0:
3051 /* xlog directory not there, must create it */
3052 printf(_("creating directory %s ... "),
3053 xlog_dir);
3054 fflush(stdout);
3055
3056 if (mkdir_p(xlog_dir, 0700) != 0)
3057 {
3058 fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
3059 progname, xlog_dir, strerror(errno));
3060 exit_nicely();
3061 }
3062 else
3063 check_ok();
3064
3065 made_new_xlogdir = true;
3066 break;
3067 case 1:
3068 /* Present but empty, fix permissions and use it */
3069 printf(_("fixing permissions on existing directory %s ... "),
3070 xlog_dir);
3071 fflush(stdout);
3072
3073 if (chmod(xlog_dir, 0700) != 0)
3074 {
3075 fprintf(stderr, _("%s: could not change permissions of directory \"%s\": %s\n"),
3076 progname, xlog_dir, strerror(errno));
3077 exit_nicely();
3078 }
3079 else
3080 check_ok();
3081
3082 found_existing_xlogdir = true;
3083 break;
3084 case 2:
3085 /* Present and not empty */
3086 fprintf(stderr,
3087 _("%s: directory \"%s\" exists but is not empty\n"),
3088 progname, xlog_dir);
3089 fprintf(stderr,
3090 _("If you want to store the transaction log there, either\n"
3091 "remove or empty the directory \"%s\".\n"),
3092 xlog_dir);
3093 exit_nicely();
3094
3095 default:
3096 /* Trouble accessing directory */
3097 fprintf(stderr, _("%s: could not access directory \"%s\": %s\n"),
3098 progname, xlog_dir, strerror(errno));
3099 exit_nicely();
3100 }
3101
3102 /* form name of the place where the symlink must go */
3103 linkloc = (char *) pg_malloc(strlen(pg_data) + 8 + 1);
3104 sprintf(linkloc, "%s/pg_xlog", pg_data);
3105
3106 #ifdef HAVE_SYMLINK
3107 if (symlink(xlog_dir, linkloc) != 0)
3108 {
3109 fprintf(stderr, _("%s: could not create symbolic link \"%s\": %s\n"),
3110 progname, linkloc, strerror(errno));
3111 exit_nicely();
3112 }
3113 #else
3114 fprintf(stderr, _("%s: symlinks are not supported on this platform"));
3115 exit_nicely();
3116 #endif
3117 }
3118
3119 /* Create required subdirectories */
3120 printf(_("creating subdirectories ... "));
3121 fflush(stdout);
3122
3123 for (i = 0; i < (sizeof(subdirs) / sizeof(char *)); i++)
3124 {
3125 if (!mkdatadir(subdirs[i]))
3126 exit_nicely();
3127 }
3128
3129 check_ok();
3130
3131 /* Top level PG_VERSION is checked by bootstrapper, so make it first */
3132 set_short_version(short_version, NULL);
3133
3134 /* Select suitable configuration settings */
3135 set_null_conf();
3136 test_config_settings();
3137
3138 /* Now create all the text config files */
3139 setup_config();
3140
3141 /* Bootstrap template1 */
3142 bootstrap_template1(short_version);
3143
3144 /*
3145 * Make the per-database PG_VERSION for template1 only after init'ing it
3146 */
3147 set_short_version(short_version, "base/1");
3148
3149 /* Create the stuff we don't need to use bootstrap mode for */
3150
3151 setup_auth();
3152 if (pwprompt || pwfilename)
3153 get_set_pwd();
3154
3155 setup_depend();
3156
3157 setup_sysviews();
3158
3159 setup_description();
3160
3161 setup_conversion();
3162
3163 setup_dictionary();
3164
3165 setup_privileges();
3166
3167 setup_schema();
3168
3169 vacuum_db();
3170
3171 make_template0();
3172
3173 make_postgres();
3174
3175 if (authwarning != NULL)
3176 fprintf(stderr, "%s", authwarning);
3177
3178 /* Get directory specification used to start this executable */
3179 strcpy(bin_dir, argv[0]);
3180 get_parent_directory(bin_dir);
3181
3182 printf(_("\nSuccess. You can now start the database server using:\n\n"
3183 " %s%s%spostgres%s -D %s%s%s\n"
3184 "or\n"
3185 " %s%s%spg_ctl%s -D %s%s%s -l logfile start\n\n"),
3186 QUOTE_PATH, bin_dir, (strlen(bin_dir) > 0) ? DIR_SEP : "", QUOTE_PATH,
3187 QUOTE_PATH, pg_data_native, QUOTE_PATH,
3188 QUOTE_PATH, bin_dir, (strlen(bin_dir) > 0) ? DIR_SEP : "", QUOTE_PATH,
3189 QUOTE_PATH, pg_data_native, QUOTE_PATH);
3190
3191 return 0;
3192 }
PostgreSQL from CVS