?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix obsolete comment regarding FSM truncation.
[PostgreSQL.git] / src / bin / pg_ctl / pg_ctl.c
blobbc756959d24a76886e759c6ff12c90d7625934eb
1 /*-------------------------------------------------------------------------
2 *
3 * pg_ctl --- start/stops/restarts the PostgreSQL server
4 *
5 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
6 *
7 * $PostgreSQL$
8 *
9 *-------------------------------------------------------------------------
10 */
11
12 #ifdef WIN32
13 /*
14 * Need this to get defines for restricted tokens and jobs. And it
15 * has to be set before any header from the Win32 API is loaded.
16 */
17 #define _WIN32_WINNT 0x0500
18 #endif
19
20 #include "postgres_fe.h"
21 #include "libpq-fe.h"
22
23 #include <locale.h>
24 #include <signal.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28
29 #ifdef HAVE_SYS_RESOURCE_H
30 #include <sys/time.h>
31 #include <sys/resource.h>
32 #endif
33
34 #include "libpq/pqsignal.h"
35 #include "getopt_long.h"
36 #include "miscadmin.h"
37
38 #if defined(__CYGWIN__)
39 #include <sys/cygwin.h>
40 #include <windows.h>
41 /* Cygwin defines WIN32 in windows.h, but we don't want it. */
42 #undef WIN32
43 #endif
44
45 #ifndef HAVE_INT_OPTRESET
46 int optreset;
47 #endif
48
49 /* PID can be negative for standalone backend */
50 typedef long pgpid_t;
51
52
53 typedef enum
54 {
55 SMART_MODE,
56 FAST_MODE,
57 IMMEDIATE_MODE
58 } ShutdownMode;
59
60
61 typedef enum
62 {
63 NO_COMMAND = 0,
64 START_COMMAND,
65 STOP_COMMAND,
66 RESTART_COMMAND,
67 RELOAD_COMMAND,
68 STATUS_COMMAND,
69 KILL_COMMAND,
70 REGISTER_COMMAND,
71 UNREGISTER_COMMAND,
72 RUN_AS_SERVICE_COMMAND
73 } CtlCommand;
74
75 #define DEFAULT_WAIT 60
76
77 static bool do_wait = false;
78 static bool wait_set = false;
79 static int wait_seconds = DEFAULT_WAIT;
80 static bool silent_mode = false;
81 static ShutdownMode shutdown_mode = SMART_MODE;
82 static int sig = SIGTERM; /* default */
83 static CtlCommand ctl_command = NO_COMMAND;
84 static char *pg_data = NULL;
85 static char *pgdata_opt = NULL;
86 static char *post_opts = NULL;
87 static const char *progname;
88 static char *log_file = NULL;
89 static char *postgres_path = NULL;
90 static char *register_servicename = "PostgreSQL"; /* FIXME: + version ID? */
91 static char *register_username = NULL;
92 static char *register_password = NULL;
93 static char *argv0 = NULL;
94 static bool allow_core_files = false;
95
96 static void
97 write_stderr(const char *fmt,...)
98 /* This extension allows gcc to check the format string for consistency with
99 the supplied arguments. */
100 __attribute__((format(printf, 1, 2)));
101 static void *pg_malloc(size_t size);
102 static char *xstrdup(const char *s);
103 static void do_advice(void);
104 static void do_help(void);
105 static void set_mode(char *modeopt);
106 static void set_sig(char *signame);
107 static void do_start(void);
108 static void do_stop(void);
109 static void do_restart(void);
110 static void do_reload(void);
111 static void do_status(void);
112 static void do_kill(pgpid_t pid);
113 static void print_msg(const char *msg);
114
115 #if defined(WIN32) || defined(__CYGWIN__)
116 static bool pgwin32_IsInstalled(SC_HANDLE);
117 static char *pgwin32_CommandLine(bool);
118 static void pgwin32_doRegister(void);
119 static void pgwin32_doUnregister(void);
120 static void pgwin32_SetServiceStatus(DWORD);
121 static void WINAPI pgwin32_ServiceHandler(DWORD);
122 static void WINAPI pgwin32_ServiceMain(DWORD, LPTSTR *);
123 static void pgwin32_doRunAsService(void);
124 static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo);
125
126 static SERVICE_STATUS status;
127 static SERVICE_STATUS_HANDLE hStatus = (SERVICE_STATUS_HANDLE) 0;
128 static HANDLE shutdownHandles[2];
129 static pid_t postmasterPID = -1;
130
131 #define shutdownEvent shutdownHandles[0]
132 #define postmasterProcess shutdownHandles[1]
133 #endif
134
135 static pgpid_t get_pgpid(void);
136 static char **readfile(const char *path);
137 static int start_postmaster(void);
138 static void read_post_opts(void);
139
140 static bool test_postmaster_connection(bool);
141 static bool postmaster_is_alive(pid_t pid);
142
143 static char postopts_file[MAXPGPATH];
144 static char pid_file[MAXPGPATH];
145 static char conf_file[MAXPGPATH];
146 static char backup_file[MAXPGPATH];
147
148 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
149 static void unlimit_core_size(void);
150 #endif
151
152
153 #if defined(WIN32) || defined(__CYGWIN__)
154 static void
155 write_eventlog(int level, const char *line)
156 {
157 static HANDLE evtHandle = INVALID_HANDLE_VALUE;
158
159 if (evtHandle == INVALID_HANDLE_VALUE)
160 {
161 evtHandle = RegisterEventSource(NULL, "PostgreSQL");
162 if (evtHandle == NULL)
163 {
164 evtHandle = INVALID_HANDLE_VALUE;
165 return;
166 }
167 }
168
169 ReportEvent(evtHandle,
170 level,
171 0,
172 0, /* All events are Id 0 */
173 NULL,
174 1,
175 0,
176 &line,
177 NULL);
178 }
179 #endif
180
181 /*
182 * Write errors to stderr (or by equal means when stderr is
183 * not available).
184 */
185 static void
186 write_stderr(const char *fmt,...)
187 {
188 va_list ap;
189
190 va_start(ap, fmt);
191 #if !defined(WIN32) && !defined(__CYGWIN__)
192 /* On Unix, we just fprintf to stderr */
193 vfprintf(stderr, fmt, ap);
194 #else
195
196 /*
197 * On Win32, we print to stderr if running on a console, or write to
198 * eventlog if running as a service
199 */
200 if (!isatty(fileno(stderr))) /* Running as a service */
201 {
202 char errbuf[2048]; /* Arbitrary size? */
203
204 vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
205
206 write_eventlog(EVENTLOG_ERROR_TYPE, errbuf);
207 }
208 else
209 /* Not running as service, write to stderr */
210 vfprintf(stderr, fmt, ap);
211 #endif
212 va_end(ap);
213 }
214
215 /*
216 * routines to check memory allocations and fail noisily.
217 */
218
219 static void *
220 pg_malloc(size_t size)
221 {
222 void *result;
223
224 result = malloc(size);
225 if (!result)
226 {
227 write_stderr(_("%s: out of memory\n"), progname);
228 exit(1);
229 }
230 return result;
231 }
232
233
234 static char *
235 xstrdup(const char *s)
236 {
237 char *result;
238
239 result = strdup(s);
240 if (!result)
241 {
242 write_stderr(_("%s: out of memory\n"), progname);
243 exit(1);
244 }
245 return result;
246 }
247
248 /*
249 * Given an already-localized string, print it to stdout unless the
250 * user has specified that no messages should be printed.
251 */
252 static void
253 print_msg(const char *msg)
254 {
255 if (!silent_mode)
256 {
257 fputs(msg, stdout);
258 fflush(stdout);
259 }
260 }
261
262 static pgpid_t
263 get_pgpid(void)
264 {
265 FILE *pidf;
266 long pid;
267
268 pidf = fopen(pid_file, "r");
269 if (pidf == NULL)
270 {
271 /* No pid file, not an error on startup */
272 if (errno == ENOENT)
273 return 0;
274 else
275 {
276 write_stderr(_("%s: could not open PID file \"%s\": %s\n"),
277 progname, pid_file, strerror(errno));
278 exit(1);
279 }
280 }
281 if (fscanf(pidf, "%ld", &pid) != 1)
282 {
283 write_stderr(_("%s: invalid data in PID file \"%s\"\n"),
284 progname, pid_file);
285 exit(1);
286 }
287 fclose(pidf);
288 return (pgpid_t) pid;
289 }
290
291
292 /*
293 * get the lines from a text file - return NULL if file can't be opened
294 */
295 static char **
296 readfile(const char *path)
297 {
298 FILE *infile;
299 int maxlength = 0,
300 linelen = 0;
301 int nlines = 0;
302 char **result;
303 char *buffer;
304 int c;
305
306 if ((infile = fopen(path, "r")) == NULL)
307 return NULL;
308
309 /* pass over the file twice - the first time to size the result */
310
311 while ((c = fgetc(infile)) != EOF)
312 {
313 linelen++;
314 if (c == '\n')
315 {
316 nlines++;
317 if (linelen > maxlength)
318 maxlength = linelen;
319 linelen = 0;
320 }
321 }
322
323 /* handle last line without a terminating newline (yuck) */
324 if (linelen)
325 nlines++;
326 if (linelen > maxlength)
327 maxlength = linelen;
328
329 /* set up the result and the line buffer */
330 result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
331 buffer = (char *) pg_malloc(maxlength + 1);
332
333 /* now reprocess the file and store the lines */
334 rewind(infile);
335 nlines = 0;
336 while (fgets(buffer, maxlength + 1, infile) != NULL)
337 result[nlines++] = xstrdup(buffer);
338
339 fclose(infile);
340 free(buffer);
341 result[nlines] = NULL;
342
343 return result;
344 }
345
346
347
348 /*
349 * start/test/stop routines
350 */
351
352 static int
353 start_postmaster(void)
354 {
355 char cmd[MAXPGPATH];
356
357 #ifndef WIN32
358
359 /*
360 * Since there might be quotes to handle here, it is easier simply to pass
361 * everything to a shell to process them.
362 */
363 if (log_file != NULL)
364 snprintf(cmd, MAXPGPATH, SYSTEMQUOTE "\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1 &" SYSTEMQUOTE,
365 postgres_path, pgdata_opt, post_opts,
366 DEVNULL, log_file);
367 else
368 snprintf(cmd, MAXPGPATH, SYSTEMQUOTE "\"%s\" %s%s < \"%s\" 2>&1 &" SYSTEMQUOTE,
369 postgres_path, pgdata_opt, post_opts, DEVNULL);
370
371 return system(cmd);
372 #else /* WIN32 */
373
374 /*
375 * On win32 we don't use system(). So we don't need to use & (which would
376 * be START /B on win32). However, we still call the shell (CMD.EXE) with
377 * it to handle redirection etc.
378 */
379 PROCESS_INFORMATION pi;
380
381 if (log_file != NULL)
382 snprintf(cmd, MAXPGPATH, "CMD /C " SYSTEMQUOTE "\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1" SYSTEMQUOTE,
383 postgres_path, pgdata_opt, post_opts, DEVNULL, log_file);
384 else
385 snprintf(cmd, MAXPGPATH, "CMD /C " SYSTEMQUOTE "\"%s\" %s%s < \"%s\" 2>&1" SYSTEMQUOTE,
386 postgres_path, pgdata_opt, post_opts, DEVNULL);
387
388 if (!CreateRestrictedProcess(cmd, &pi))
389 return GetLastError();
390 CloseHandle(pi.hProcess);
391 CloseHandle(pi.hThread);
392 return 0;
393 #endif /* WIN32 */
394 }
395
396
397
398 /*
399 * Find the pgport and try a connection
400 * Note that the checkpoint parameter enables a Windows service control
401 * manager checkpoint, it's got nothing to do with database checkpoints!!
402 */
403 static bool
404 test_postmaster_connection(bool do_checkpoint)
405 {
406 PGconn *conn;
407 bool success = false;
408 int i;
409 char portstr[32];
410 char *p;
411 char *q;
412 char connstr[128]; /* Should be way more than enough! */
413
414 *portstr = '\0';
415
416 /*
417 * Look in post_opts for a -p switch.
418 *
419 * This parsing code is not amazingly bright; it could for instance
420 * get fooled if ' -p' occurs within a quoted argument value. Given
421 * that few people pass complicated settings in post_opts, it's
422 * probably good enough.
423 */
424 for (p = post_opts; *p;)
425 {
426 /* advance past whitespace */
427 while (isspace((unsigned char) *p))
428 p++;
429
430 if (strncmp(p, "-p", 2) == 0)
431 {
432 p += 2;
433 /* advance past any whitespace/quoting */
434 while (isspace((unsigned char) *p) || *p == '\'' || *p == '"')
435 p++;
436 /* find end of value (not including any ending quote!) */
437 q = p;
438 while (*q &&
439 !(isspace((unsigned char) *q) || *q == '\'' || *q == '"'))
440 q++;
441 /* and save the argument value */
442 strlcpy(portstr, p, Min((q - p) + 1, sizeof(portstr)));
443 /* keep looking, maybe there is another -p */
444 p = q;
445 }
446 /* Advance to next whitespace */
447 while (*p && !isspace((unsigned char) *p))
448 p++;
449 }
450
451 /*
452 * Search config file for a 'port' option.
453 *
454 * This parsing code isn't amazingly bright either, but it should be
455 * okay for valid port settings.
456 */
457 if (!*portstr)
458 {
459 char **optlines;
460
461 optlines = readfile(conf_file);
462 if (optlines != NULL)
463 {
464 for (; *optlines != NULL; optlines++)
465 {
466 p = *optlines;
467
468 while (isspace((unsigned char) *p))
469 p++;
470 if (strncmp(p, "port", 4) != 0)
471 continue;
472 p += 4;
473 while (isspace((unsigned char) *p))
474 p++;
475 if (*p != '=')
476 continue;
477 p++;
478 /* advance past any whitespace/quoting */
479 while (isspace((unsigned char) *p) || *p == '\'' || *p == '"')
480 p++;
481 /* find end of value (not including any ending quote/comment!) */
482 q = p;
483 while (*q &&
484 !(isspace((unsigned char) *q) ||
485 *q == '\'' || *q == '"' || *q == '#'))
486 q++;
487 /* and save the argument value */
488 strlcpy(portstr, p, Min((q - p) + 1, sizeof(portstr)));
489 /* keep looking, maybe there is another */
490 }
491 }
492 }
493
494 /* Check environment */
495 if (!*portstr && getenv("PGPORT") != NULL)
496 strlcpy(portstr, getenv("PGPORT"), sizeof(portstr));
497
498 /* Else use compiled-in default */
499 if (!*portstr)
500 snprintf(portstr, sizeof(portstr), "%d", DEF_PGPORT);
501
502 /*
503 * We need to set a connect timeout otherwise on Windows the SCM will
504 * probably timeout first
505 */
506 snprintf(connstr, sizeof(connstr),
507 "dbname=postgres port=%s connect_timeout=5", portstr);
508
509 for (i = 0; i < wait_seconds; i++)
510 {
511 if ((conn = PQconnectdb(connstr)) != NULL &&
512 (PQstatus(conn) == CONNECTION_OK ||
513 PQconnectionNeedsPassword(conn)))
514 {
515 PQfinish(conn);
516 success = true;
517 break;
518 }
519 else
520 {
521 PQfinish(conn);
522
523 #if defined(WIN32)
524 if (do_checkpoint)
525 {
526 /*
527 * Increment the wait hint by 6 secs (connection timeout +
528 * sleep) We must do this to indicate to the SCM that our
529 * startup time is changing, otherwise it'll usually send a
530 * stop signal after 20 seconds, despite incrementing the
531 * checkpoint counter.
532 */
533 status.dwWaitHint += 6000;
534 status.dwCheckPoint++;
535 SetServiceStatus(hStatus, (LPSERVICE_STATUS) & status);
536 }
537
538 else
539 #endif
540 print_msg(".");
541
542 pg_usleep(1000000); /* 1 sec */
543 }
544 }
545
546 return success;
547 }
548
549
550 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
551 static void
552 unlimit_core_size(void)
553 {
554 struct rlimit lim;
555
556 getrlimit(RLIMIT_CORE, &lim);
557 if (lim.rlim_max == 0)
558 {
559 write_stderr(_("%s: cannot set core file size limit; disallowed by hard limit\n"),
560 progname);
561 return;
562 }
563 else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
564 {
565 lim.rlim_cur = lim.rlim_max;
566 setrlimit(RLIMIT_CORE, &lim);
567 }
568 }
569 #endif
570
571 static void
572 read_post_opts(void)
573 {
574 if (post_opts == NULL)
575 {
576 post_opts = ""; /* default */
577 if (ctl_command == RESTART_COMMAND)
578 {
579 char **optlines;
580
581 optlines = readfile(postopts_file);
582 if (optlines == NULL)
583 {
584 write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
585 exit(1);
586 }
587 else if (optlines[0] == NULL || optlines[1] != NULL)
588 {
589 write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
590 progname, postopts_file);
591 exit(1);
592 }
593 else
594 {
595 int len;
596 char *optline;
597 char *arg1;
598
599 optline = optlines[0];
600 /* trim off line endings */
601 len = strcspn(optline, "\r\n");
602 optline[len] = '\0';
603
604 /*
605 * Are we at the first option, as defined by space and
606 * double-quote?
607 */
608 if ((arg1 = strstr(optline, " \"")) != NULL)
609 {
610 *arg1 = '\0'; /* terminate so we get only program name */
611 post_opts = arg1 + 1; /* point past whitespace */
612 }
613 if (postgres_path == NULL)
614 postgres_path = optline;
615 }
616 }
617 }
618 }
619
620 static void
621 do_start(void)
622 {
623 pgpid_t pid;
624 pgpid_t old_pid = 0;
625 int exitcode;
626
627 if (ctl_command != RESTART_COMMAND)
628 {
629 old_pid = get_pgpid();
630 if (old_pid != 0)
631 write_stderr(_("%s: another server might be running; "
632 "trying to start server anyway\n"),
633 progname);
634 }
635
636 read_post_opts();
637
638 /* No -D or -D already added during server start */
639 if (ctl_command == RESTART_COMMAND || pgdata_opt == NULL)
640 pgdata_opt = "";
641
642 if (postgres_path == NULL)
643 {
644 char *postmaster_path;
645 int ret;
646
647 postmaster_path = pg_malloc(MAXPGPATH);
648
649 if ((ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR,
650 postmaster_path)) < 0)
651 {
652 char full_path[MAXPGPATH];
653
654 if (find_my_exec(argv0, full_path) < 0)
655 strlcpy(full_path, progname, sizeof(full_path));
656
657 if (ret == -1)
658 write_stderr(_("The program \"postgres\" is needed by %s "
659 "but was not found in the\n"
660 "same directory as \"%s\".\n"
661 "Check your installation.\n"),
662 progname, full_path);
663 else
664 write_stderr(_("The program \"postgres\" was found by \"%s\"\n"
665 "but was not the same version as %s.\n"
666 "Check your installation.\n"),
667 full_path, progname);
668 exit(1);
669 }
670 postgres_path = postmaster_path;
671 }
672
673 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
674 if (allow_core_files)
675 unlimit_core_size();
676 #endif
677
678 exitcode = start_postmaster();
679 if (exitcode != 0)
680 {
681 write_stderr(_("%s: could not start server: exit code was %d\n"),
682 progname, exitcode);
683 exit(1);
684 }
685
686 if (old_pid != 0)
687 {
688 pg_usleep(1000000);
689 pid = get_pgpid();
690 if (pid == old_pid)
691 {
692 write_stderr(_("%s: could not start server\n"
693 "Examine the log output.\n"),
694 progname);
695 exit(1);
696 }
697 }
698
699 if (do_wait)
700 {
701 print_msg(_("waiting for server to start..."));
702
703 if (test_postmaster_connection(false) == false)
704 {
705 printf(_("could not start server\n"));
706 exit(1);
707 }
708 else
709 {
710 print_msg(_(" done\n"));
711 print_msg(_("server started\n"));
712 }
713 }
714 else
715 print_msg(_("server starting\n"));
716 }
717
718
719 static void
720 do_stop(void)
721 {
722 int cnt;
723 pgpid_t pid;
724 struct stat statbuf;
725
726 pid = get_pgpid();
727
728 if (pid == 0) /* no pid file */
729 {
730 write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
731 write_stderr(_("Is server running?\n"));
732 exit(1);
733 }
734 else if (pid < 0) /* standalone backend, not postmaster */
735 {
736 pid = -pid;
737 write_stderr(_("%s: cannot stop server; "
738 "single-user server is running (PID: %ld)\n"),
739 progname, pid);
740 exit(1);
741 }
742
743 if (kill((pid_t) pid, sig) != 0)
744 {
745 write_stderr(_("%s: could not send stop signal (PID: %ld): %s\n"), progname, pid,
746 strerror(errno));
747 exit(1);
748 }
749
750 if (!do_wait)
751 {
752 print_msg(_("server shutting down\n"));
753 return;
754 }
755 else
756 {
757 if ((shutdown_mode == SMART_MODE) && (stat(backup_file, &statbuf) == 0))
758 {
759 print_msg(_("WARNING: online backup mode is active.\n"
760 "Shutdown will not complete until pg_stop_backup() is called.\n\n"));
761 }
762
763 print_msg(_("waiting for server to shut down..."));
764
765 for (cnt = 0; cnt < wait_seconds; cnt++)
766 {
767 if ((pid = get_pgpid()) != 0)
768 {
769 print_msg(".");
770 pg_usleep(1000000); /* 1 sec */
771 }
772 else
773 break;
774 }
775
776 if (pid != 0) /* pid file still exists */
777 {
778 print_msg(_(" failed\n"));
779
780 write_stderr(_("%s: server does not shut down\n"), progname);
781 exit(1);
782 }
783 print_msg(_(" done\n"));
784
785 printf(_("server stopped\n"));
786 }
787 }
788
789
790 /*
791 * restart/reload routines
792 */
793
794 static void
795 do_restart(void)
796 {
797 int cnt;
798 pgpid_t pid;
799 struct stat statbuf;
800
801 pid = get_pgpid();
802
803 if (pid == 0) /* no pid file */
804 {
805 write_stderr(_("%s: PID file \"%s\" does not exist\n"),
806 progname, pid_file);
807 write_stderr(_("Is server running?\n"));
808 write_stderr(_("starting server anyway\n"));
809 do_start();
810 return;
811 }
812 else if (pid < 0) /* standalone backend, not postmaster */
813 {
814 pid = -pid;
815 if (postmaster_is_alive((pid_t) pid))
816 {
817 write_stderr(_("%s: cannot restart server; "
818 "single-user server is running (PID: %ld)\n"),
819 progname, pid);
820 write_stderr(_("Please terminate the single-user server and try again.\n"));
821 exit(1);
822 }
823 }
824
825 if (postmaster_is_alive((pid_t) pid))
826 {
827 if (kill((pid_t) pid, sig) != 0)
828 {
829 write_stderr(_("%s: could not send stop signal (PID: %ld): %s\n"), progname, pid,
830 strerror(errno));
831 exit(1);
832 }
833
834 if ((shutdown_mode == SMART_MODE) && (stat(backup_file, &statbuf) == 0))
835 {
836 print_msg(_("WARNING: online backup mode is active.\n"
837 "Shutdown will not complete until pg_stop_backup() is called.\n\n"));
838 }
839
840 print_msg(_("waiting for server to shut down..."));
841
842 /* always wait for restart */
843
844 for (cnt = 0; cnt < wait_seconds; cnt++)
845 {
846 if ((pid = get_pgpid()) != 0)
847 {
848 print_msg(".");
849 pg_usleep(1000000); /* 1 sec */
850 }
851 else
852 break;
853 }
854
855 if (pid != 0) /* pid file still exists */
856 {
857 print_msg(_(" failed\n"));
858
859 write_stderr(_("%s: server does not shut down\n"), progname);
860 exit(1);
861 }
862
863 print_msg(_(" done\n"));
864 printf(_("server stopped\n"));
865 }
866 else
867 {
868 write_stderr(_("%s: old server process (PID: %ld) seems to be gone\n"),
869 progname, pid);
870 write_stderr(_("starting server anyway\n"));
871 }
872
873 do_start();
874 }
875
876
877 static void
878 do_reload(void)
879 {
880 pgpid_t pid;
881
882 pid = get_pgpid();
883 if (pid == 0) /* no pid file */
884 {
885 write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
886 write_stderr(_("Is server running?\n"));
887 exit(1);
888 }
889 else if (pid < 0) /* standalone backend, not postmaster */
890 {
891 pid = -pid;
892 write_stderr(_("%s: cannot reload server; "
893 "single-user server is running (PID: %ld)\n"),
894 progname, pid);
895 write_stderr(_("Please terminate the single-user server and try again.\n"));
896 exit(1);
897 }
898
899 if (kill((pid_t) pid, sig) != 0)
900 {
901 write_stderr(_("%s: could not send reload signal (PID: %ld): %s\n"),
902 progname, pid, strerror(errno));
903 exit(1);
904 }
905
906 print_msg(_("server signaled\n"));
907 }
908
909 /*
910 * utility routines
911 */
912
913 static bool
914 postmaster_is_alive(pid_t pid)
915 {
916 /*
917 * Test to see if the process is still there. Note that we do not
918 * consider an EPERM failure to mean that the process is still there;
919 * EPERM must mean that the given PID belongs to some other userid, and
920 * considering the permissions on $PGDATA, that means it's not the
921 * postmaster we are after.
922 *
923 * Don't believe that our own PID or parent shell's PID is the postmaster,
924 * either. (Windows hasn't got getppid(), though.)
925 */
926 if (pid == getpid())
927 return false;
928 #ifndef WIN32
929 if (pid == getppid())
930 return false;
931 #endif
932 if (kill(pid, 0) == 0)
933 return true;
934 return false;
935 }
936
937 static void
938 do_status(void)
939 {
940 pgpid_t pid;
941
942 pid = get_pgpid();
943 if (pid != 0) /* 0 means no pid file */
944 {
945 if (pid < 0) /* standalone backend */
946 {
947 pid = -pid;
948 if (postmaster_is_alive((pid_t) pid))
949 {
950 printf(_("%s: single-user server is running (PID: %ld)\n"),
951 progname, pid);
952 return;
953 }
954 }
955 else
956 /* postmaster */
957 {
958 if (postmaster_is_alive((pid_t) pid))
959 {
960 char **optlines;
961
962 printf(_("%s: server is running (PID: %ld)\n"),
963 progname, pid);
964
965 optlines = readfile(postopts_file);
966 if (optlines != NULL)
967 for (; *optlines != NULL; optlines++)
968 fputs(*optlines, stdout);
969 return;
970 }
971 }
972 }
973 printf(_("%s: no server running\n"), progname);
974 exit(1);
975 }
976
977
978
979 static void
980 do_kill(pgpid_t pid)
981 {
982 if (kill((pid_t) pid, sig) != 0)
983 {
984 write_stderr(_("%s: could not send signal %d (PID: %ld): %s\n"),
985 progname, sig, pid, strerror(errno));
986 exit(1);
987 }
988 }
989
990 #if defined(WIN32) || defined(__CYGWIN__)
991
992 static bool
993 pgwin32_IsInstalled(SC_HANDLE hSCM)
994 {
995 SC_HANDLE hService = OpenService(hSCM, register_servicename, SERVICE_QUERY_CONFIG);
996 bool bResult = (hService != NULL);
997
998 if (bResult)
999 CloseServiceHandle(hService);
1000 return bResult;
1001 }
1002
1003 static char *
1004 pgwin32_CommandLine(bool registration)
1005 {
1006 static char cmdLine[MAXPGPATH];
1007 int ret;
1008
1009 #ifdef __CYGWIN__
1010 char buf[MAXPGPATH];
1011 #endif
1012
1013 if (registration)
1014 {
1015 ret = find_my_exec(argv0, cmdLine);
1016 if (ret != 0)
1017 {
1018 write_stderr(_("%s: could not find own program executable\n"), progname);
1019 exit(1);
1020 }
1021 }
1022 else
1023 {
1024 ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR,
1025 cmdLine);
1026 if (ret != 0)
1027 {
1028 write_stderr(_("%s: could not find postgres program executable\n"), progname);
1029 exit(1);
1030 }
1031 }
1032
1033 #ifdef __CYGWIN__
1034 /* need to convert to windows path */
1035 cygwin_conv_to_full_win32_path(cmdLine, buf);
1036 strcpy(cmdLine, buf);
1037 #endif
1038
1039 if (registration)
1040 {
1041 if (pg_strcasecmp(cmdLine + strlen(cmdLine) - 4, ".exe"))
1042 {
1043 /* If commandline does not end in .exe, append it */
1044 strcat(cmdLine, ".exe");
1045 }
1046 strcat(cmdLine, " runservice -N \"");
1047 strcat(cmdLine, register_servicename);
1048 strcat(cmdLine, "\"");
1049 }
1050
1051 if (pg_data)
1052 {
1053 strcat(cmdLine, " -D \"");
1054 strcat(cmdLine, pg_data);
1055 strcat(cmdLine, "\"");
1056 }
1057
1058 if (registration && do_wait)
1059 strcat(cmdLine, " -w");
1060
1061 if (registration && wait_seconds != DEFAULT_WAIT)
1062 /* concatenate */
1063 sprintf(cmdLine + strlen(cmdLine), " -t %d", wait_seconds);
1064
1065 if (post_opts)
1066 {
1067 strcat(cmdLine, " ");
1068 if (registration)
1069 strcat(cmdLine, " -o \"");
1070 strcat(cmdLine, post_opts);
1071 if (registration)
1072 strcat(cmdLine, "\"");
1073 }
1074
1075 return cmdLine;
1076 }
1077
1078 static void
1079 pgwin32_doRegister(void)
1080 {
1081 SC_HANDLE hService;
1082 SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
1083
1084 if (hSCM == NULL)
1085 {
1086 write_stderr(_("%s: could not open service manager\n"), progname);
1087 exit(1);
1088 }
1089 if (pgwin32_IsInstalled(hSCM))
1090 {
1091 CloseServiceHandle(hSCM);
1092 write_stderr(_("%s: service \"%s\" already registered\n"), progname, register_servicename);
1093 exit(1);
1094 }
1095
1096 if ((hService = CreateService(hSCM, register_servicename, register_servicename,
1097 SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
1098 SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
1099 pgwin32_CommandLine(true),
1100 NULL, NULL, "RPCSS\0", register_username, register_password)) == NULL)
1101 {
1102 CloseServiceHandle(hSCM);
1103 write_stderr(_("%s: could not register service \"%s\": error code %d\n"), progname, register_servicename, (int) GetLastError());
1104 exit(1);
1105 }
1106 CloseServiceHandle(hService);
1107 CloseServiceHandle(hSCM);
1108 }
1109
1110 static void
1111 pgwin32_doUnregister(void)
1112 {
1113 SC_HANDLE hService;
1114 SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
1115
1116 if (hSCM == NULL)
1117 {
1118 write_stderr(_("%s: could not open service manager\n"), progname);
1119 exit(1);
1120 }
1121 if (!pgwin32_IsInstalled(hSCM))
1122 {
1123 CloseServiceHandle(hSCM);
1124 write_stderr(_("%s: service \"%s\" not registered\n"), progname, register_servicename);
1125 exit(1);
1126 }
1127
1128 if ((hService = OpenService(hSCM, register_servicename, DELETE)) == NULL)
1129 {
1130 CloseServiceHandle(hSCM);
1131 write_stderr(_("%s: could not open service \"%s\": error code %d\n"), progname, register_servicename, (int) GetLastError());
1132 exit(1);
1133 }
1134 if (!DeleteService(hService))
1135 {
1136 CloseServiceHandle(hService);
1137 CloseServiceHandle(hSCM);
1138 write_stderr(_("%s: could not unregister service \"%s\": error code %d\n"), progname, register_servicename, (int) GetLastError());
1139 exit(1);
1140 }
1141 CloseServiceHandle(hService);
1142 CloseServiceHandle(hSCM);
1143 }
1144
1145 static void
1146 pgwin32_SetServiceStatus(DWORD currentState)
1147 {
1148 status.dwCurrentState = currentState;
1149 SetServiceStatus(hStatus, (LPSERVICE_STATUS) & status);
1150 }
1151
1152 static void WINAPI
1153 pgwin32_ServiceHandler(DWORD request)
1154 {
1155 switch (request)
1156 {
1157 case SERVICE_CONTROL_STOP:
1158 case SERVICE_CONTROL_SHUTDOWN:
1159
1160 /*
1161 * We only need a short wait hint here as it just needs to wait
1162 * for the next checkpoint. They occur every 5 seconds during
1163 * shutdown
1164 */
1165 status.dwWaitHint = 10000;
1166 pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
1167 SetEvent(shutdownEvent);
1168 return;
1169
1170 case SERVICE_CONTROL_PAUSE:
1171 /* Win32 config reloading */
1172 status.dwWaitHint = 5000;
1173 kill(postmasterPID, SIGHUP);
1174 return;
1175
1176 /* FIXME: These could be used to replace other signals etc */
1177 case SERVICE_CONTROL_CONTINUE:
1178 case SERVICE_CONTROL_INTERROGATE:
1179 default:
1180 break;
1181 }
1182 }
1183
1184 static void WINAPI
1185 pgwin32_ServiceMain(DWORD argc, LPTSTR * argv)
1186 {
1187 PROCESS_INFORMATION pi;
1188 DWORD ret;
1189 DWORD check_point_start;
1190
1191 /* Initialize variables */
1192 status.dwWin32ExitCode = S_OK;
1193 status.dwCheckPoint = 0;
1194 status.dwWaitHint = 60000;
1195 status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
1196 status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE;
1197 status.dwServiceSpecificExitCode = 0;
1198 status.dwCurrentState = SERVICE_START_PENDING;
1199
1200 memset(&pi, 0, sizeof(pi));
1201
1202 read_post_opts();
1203
1204 /* Register the control request handler */
1205 if ((hStatus = RegisterServiceCtrlHandler(register_servicename, pgwin32_ServiceHandler)) == (SERVICE_STATUS_HANDLE) 0)
1206 return;
1207
1208 if ((shutdownEvent = CreateEvent(NULL, true, false, NULL)) == NULL)
1209 return;
1210
1211 /* Start the postmaster */
1212 pgwin32_SetServiceStatus(SERVICE_START_PENDING);
1213 if (!CreateRestrictedProcess(pgwin32_CommandLine(false), &pi))
1214 {
1215 pgwin32_SetServiceStatus(SERVICE_STOPPED);
1216 return;
1217 }
1218 postmasterPID = pi.dwProcessId;
1219 postmasterProcess = pi.hProcess;
1220 CloseHandle(pi.hThread);
1221
1222 if (do_wait)
1223 {
1224 write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Waiting for server startup...\n"));
1225 if (test_postmaster_connection(true) == false)
1226 {
1227 write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Timed out waiting for server startup\n"));
1228 pgwin32_SetServiceStatus(SERVICE_STOPPED);
1229 return;
1230 }
1231 write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Server started and accepting connections\n"));
1232 }
1233
1234 /*
1235 * Save the checkpoint value as it might have been incremented in
1236 * test_postmaster_connection
1237 */
1238 check_point_start = status.dwCheckPoint;
1239
1240 pgwin32_SetServiceStatus(SERVICE_RUNNING);
1241
1242 /* Wait for quit... */
1243 ret = WaitForMultipleObjects(2, shutdownHandles, FALSE, INFINITE);
1244
1245 pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
1246 switch (ret)
1247 {
1248 case WAIT_OBJECT_0: /* shutdown event */
1249 kill(postmasterPID, SIGINT);
1250
1251 /*
1252 * Increment the checkpoint and try again Abort after 12
1253 * checkpoints as the postmaster has probably hung
1254 */
1255 while (WaitForSingleObject(postmasterProcess, 5000) == WAIT_TIMEOUT && status.dwCheckPoint < 12)
1256 status.dwCheckPoint++;
1257 break;
1258
1259 case (WAIT_OBJECT_0 + 1): /* postmaster went down */
1260 break;
1261
1262 default:
1263 /* shouldn't get here? */
1264 break;
1265 }
1266
1267 CloseHandle(shutdownEvent);
1268 CloseHandle(postmasterProcess);
1269
1270 pgwin32_SetServiceStatus(SERVICE_STOPPED);
1271 }
1272
1273 static void
1274 pgwin32_doRunAsService(void)
1275 {
1276 SERVICE_TABLE_ENTRY st[] = {{register_servicename, pgwin32_ServiceMain},
1277 {NULL, NULL}};
1278
1279 if (StartServiceCtrlDispatcher(st) == 0)
1280 {
1281 write_stderr(_("%s: could not start service \"%s\": error code %d\n"), progname, register_servicename, (int) GetLastError());
1282 exit(1);
1283 }
1284 }
1285
1286
1287 /*
1288 * Mingw headers are incomplete, and so are the libraries. So we have to load
1289 * a whole lot of API functions dynamically. Since we have to do this anyway,
1290 * also load the couple of functions that *do* exist in minwg headers but not
1291 * on NT4. That way, we don't break on NT4.
1292 */
1293 typedef BOOL(WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
1294 typedef BOOL(WINAPI * __IsProcessInJob) (HANDLE, HANDLE, PBOOL);
1295 typedef HANDLE(WINAPI * __CreateJobObject) (LPSECURITY_ATTRIBUTES, LPCTSTR);
1296 typedef BOOL(WINAPI * __SetInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
1297 typedef BOOL(WINAPI * __AssignProcessToJobObject) (HANDLE, HANDLE);
1298 typedef BOOL(WINAPI * __QueryInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
1299
1300 /* Windows API define missing from MingW headers */
1301 #define DISABLE_MAX_PRIVILEGE 0x1
1302
1303 /*
1304 * Create a restricted token, a job object sandbox, and execute the specified
1305 * process with it.
1306 *
1307 * Returns 0 on success, non-zero on failure, same as CreateProcess().
1308 *
1309 * On NT4, or any other system not containing the required functions, will
1310 * launch the process under the current token without doing any modifications.
1311 *
1312 * NOTE! Job object will only work when running as a service, because it's
1313 * automatically destroyed when pg_ctl exits.
1314 */
1315 static int
1316 CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo)
1317 {
1318 int r;
1319 BOOL b;
1320 STARTUPINFO si;
1321 HANDLE origToken;
1322 HANDLE restrictedToken;
1323 SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
1324 SID_AND_ATTRIBUTES dropSids[2];
1325
1326 /* Functions loaded dynamically */
1327 __CreateRestrictedToken _CreateRestrictedToken = NULL;
1328 __IsProcessInJob _IsProcessInJob = NULL;
1329 __CreateJobObject _CreateJobObject = NULL;
1330 __SetInformationJobObject _SetInformationJobObject = NULL;
1331 __AssignProcessToJobObject _AssignProcessToJobObject = NULL;
1332 __QueryInformationJobObject _QueryInformationJobObject = NULL;
1333 HANDLE Kernel32Handle;
1334 HANDLE Advapi32Handle;
1335
1336 ZeroMemory(&si, sizeof(si));
1337 si.cb = sizeof(si);
1338
1339 Advapi32Handle = LoadLibrary("ADVAPI32.DLL");
1340 if (Advapi32Handle != NULL)
1341 {
1342 _CreateRestrictedToken = (__CreateRestrictedToken) GetProcAddress(Advapi32Handle, "CreateRestrictedToken");
1343 }
1344
1345 if (_CreateRestrictedToken == NULL)
1346 {
1347 /*
1348 * NT4 doesn't have CreateRestrictedToken, so just call ordinary
1349 * CreateProcess
1350 */
1351 write_stderr("WARNING: cannot create restricted tokens on this platform\n");
1352 if (Advapi32Handle != NULL)
1353 FreeLibrary(Advapi32Handle);
1354 return CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, processInfo);
1355 }
1356
1357 /* Open the current token to use as a base for the restricted one */
1358 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &origToken))
1359 {
1360 write_stderr("Failed to open process token: %lu\n", GetLastError());
1361 return 0;
1362 }
1363
1364 /* Allocate list of SIDs to remove */
1365 ZeroMemory(&dropSids, sizeof(dropSids));
1366 if (!AllocateAndInitializeSid(&NtAuthority, 2,
1367 SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0,
1368 0, &dropSids[0].Sid) ||
1369 !AllocateAndInitializeSid(&NtAuthority, 2,
1370 SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_POWER_USERS, 0, 0, 0, 0, 0,
1371 0, &dropSids[1].Sid))
1372 {
1373 write_stderr("Failed to allocate SIDs: %lu\n", GetLastError());
1374 return 0;
1375 }
1376
1377 b = _CreateRestrictedToken(origToken,
1378 DISABLE_MAX_PRIVILEGE,
1379 sizeof(dropSids) / sizeof(dropSids[0]),
1380 dropSids,
1381 0, NULL,
1382 0, NULL,
1383 &restrictedToken);
1384
1385 FreeSid(dropSids[1].Sid);
1386 FreeSid(dropSids[0].Sid);
1387 CloseHandle(origToken);
1388 FreeLibrary(Advapi32Handle);
1389
1390 if (!b)
1391 {
1392 write_stderr("Failed to create restricted token: %lu\n", GetLastError());
1393 return 0;
1394 }
1395
1396 r = CreateProcessAsUser(restrictedToken, NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, processInfo);
1397
1398 Kernel32Handle = LoadLibrary("KERNEL32.DLL");
1399 if (Kernel32Handle != NULL)
1400 {
1401 _IsProcessInJob = (__IsProcessInJob) GetProcAddress(Kernel32Handle, "IsProcessInJob");
1402 _CreateJobObject = (__CreateJobObject) GetProcAddress(Kernel32Handle, "CreateJobObjectA");
1403 _SetInformationJobObject = (__SetInformationJobObject) GetProcAddress(Kernel32Handle, "SetInformationJobObject");
1404 _AssignProcessToJobObject = (__AssignProcessToJobObject) GetProcAddress(Kernel32Handle, "AssignProcessToJobObject");
1405 _QueryInformationJobObject = (__QueryInformationJobObject) GetProcAddress(Kernel32Handle, "QueryInformationJobObject");
1406 }
1407
1408 /* Verify that we found all functions */
1409 if (_IsProcessInJob == NULL || _CreateJobObject == NULL || _SetInformationJobObject == NULL || _AssignProcessToJobObject == NULL || _QueryInformationJobObject == NULL)
1410 {
1411 /*
1412 * IsProcessInJob() is not available on < WinXP, so there is no need
1413 * to log the error every time in that case
1414 */
1415 OSVERSIONINFO osv;
1416
1417 osv.dwOSVersionInfoSize = sizeof(osv);
1418 if (!GetVersionEx(&osv) || /* could not get version */
1419 (osv.dwMajorVersion == 5 && osv.dwMinorVersion > 0) || /* 5.1=xp, 5.2=2003, etc */
1420 osv.dwMajorVersion > 5) /* anything newer should have the API */
1421
1422 /*
1423 * Log error if we can't get version, or if we're on WinXP/2003 or
1424 * newer
1425 */
1426 write_stderr("WARNING: could not locate all job object functions in system API\n");
1427 }
1428 else
1429 {
1430 BOOL inJob;
1431
1432 if (_IsProcessInJob(processInfo->hProcess, NULL, &inJob))
1433 {
1434 if (!inJob)
1435 {
1436 /*
1437 * Job objects are working, and the new process isn't in one,
1438 * so we can create one safely. If any problems show up when
1439 * setting it, we're going to ignore them.
1440 */
1441 HANDLE job;
1442 char jobname[128];
1443
1444 sprintf(jobname, "PostgreSQL_%lu", processInfo->dwProcessId);
1445
1446 job = _CreateJobObject(NULL, jobname);
1447 if (job)
1448 {
1449 JOBOBJECT_BASIC_LIMIT_INFORMATION basicLimit;
1450 JOBOBJECT_BASIC_UI_RESTRICTIONS uiRestrictions;
1451 JOBOBJECT_SECURITY_LIMIT_INFORMATION securityLimit;
1452
1453 ZeroMemory(&basicLimit, sizeof(basicLimit));
1454 ZeroMemory(&uiRestrictions, sizeof(uiRestrictions));
1455 ZeroMemory(&securityLimit, sizeof(securityLimit));
1456
1457 basicLimit.LimitFlags = JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION | JOB_OBJECT_LIMIT_PRIORITY_CLASS;
1458 basicLimit.PriorityClass = NORMAL_PRIORITY_CLASS;
1459 _SetInformationJobObject(job, JobObjectBasicLimitInformation, &basicLimit, sizeof(basicLimit));
1460
1461 uiRestrictions.UIRestrictionsClass = JOB_OBJECT_UILIMIT_DESKTOP | JOB_OBJECT_UILIMIT_DISPLAYSETTINGS |
1462 JOB_OBJECT_UILIMIT_EXITWINDOWS | JOB_OBJECT_UILIMIT_HANDLES | JOB_OBJECT_UILIMIT_READCLIPBOARD |
1463 JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS | JOB_OBJECT_UILIMIT_WRITECLIPBOARD;
1464 _SetInformationJobObject(job, JobObjectBasicUIRestrictions, &uiRestrictions, sizeof(uiRestrictions));
1465
1466 securityLimit.SecurityLimitFlags = JOB_OBJECT_SECURITY_NO_ADMIN | JOB_OBJECT_SECURITY_ONLY_TOKEN;
1467 securityLimit.JobToken = restrictedToken;
1468 _SetInformationJobObject(job, JobObjectSecurityLimitInformation, &securityLimit, sizeof(securityLimit));
1469
1470 _AssignProcessToJobObject(job, processInfo->hProcess);
1471 }
1472 }
1473 }
1474 }
1475
1476 #ifndef __CYGWIN__
1477 AddUserToDacl(processInfo->hProcess);
1478 #endif
1479
1480 CloseHandle(restrictedToken);
1481
1482 ResumeThread(processInfo->hThread);
1483
1484 FreeLibrary(Kernel32Handle);
1485
1486 /*
1487 * We intentionally don't close the job object handle, because we want the
1488 * object to live on until pg_ctl shuts down.
1489 */
1490 return r;
1491 }
1492 #endif
1493
1494 static void
1495 do_advice(void)
1496 {
1497 write_stderr(_("Try \"%s --help\" for more information.\n"), progname);
1498 }
1499
1500
1501
1502 static void
1503 do_help(void)
1504 {
1505 printf(_("%s is a utility to start, stop, restart, reload configuration files,\n"
1506 "report the status of a PostgreSQL server, or signal a PostgreSQL process.\n\n"), progname);
1507 printf(_("Usage:\n"));
1508 printf(_(" %s start [-w] [-t SECS] [-D DATADIR] [-s] [-l FILENAME] [-o \"OPTIONS\"]\n"), progname);
1509 printf(_(" %s stop [-W] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n"), progname);
1510 printf(_(" %s restart [-w] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n"
1511 " [-o \"OPTIONS\"]\n"), progname);
1512 printf(_(" %s reload [-D DATADIR] [-s]\n"), progname);
1513 printf(_(" %s status [-D DATADIR]\n"), progname);
1514 printf(_(" %s kill SIGNALNAME PID\n"), progname);
1515 #if defined(WIN32) || defined(__CYGWIN__)
1516 printf(_(" %s register [-N SERVICENAME] [-U USERNAME] [-P PASSWORD] [-D DATADIR]\n"
1517 " [-w] [-t SECS] [-o \"OPTIONS\"]\n"), progname);
1518 printf(_(" %s unregister [-N SERVICENAME]\n"), progname);
1519 #endif
1520
1521 printf(_("\nCommon options:\n"));
1522 printf(_(" -D, --pgdata DATADIR location of the database storage area\n"));
1523 printf(_(" -s, --silent only print errors, no informational messages\n"));
1524 printf(_(" -t SECS seconds to wait when using -w option\n"));
1525 printf(_(" -w wait until operation completes\n"));
1526 printf(_(" -W do not wait until operation completes\n"));
1527 printf(_(" --help show this help, then exit\n"));
1528 printf(_(" --version output version information, then exit\n"));
1529 printf(_("(The default is to wait for shutdown, but not for start or restart.)\n\n"));
1530 printf(_("If the -D option is omitted, the environment variable PGDATA is used.\n"));
1531
1532 printf(_("\nOptions for start or restart:\n"));
1533 printf(_(" -l, --log FILENAME write (or append) server log to FILENAME\n"));
1534 printf(_(" -o OPTIONS command line options to pass to postgres\n"
1535 " (PostgreSQL server executable)\n"));
1536 printf(_(" -p PATH-TO-POSTGRES normally not necessary\n"));
1537 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
1538 printf(_(" -c, --core-files allow postgres to produce core files\n"));
1539 #else
1540 printf(_(" -c, --core-files not applicable on this platform\n"));
1541 #endif
1542 printf(_("\nOptions for stop or restart:\n"));
1543 printf(_(" -m SHUTDOWN-MODE can be \"smart\", \"fast\", or \"immediate\"\n"));
1544
1545 printf(_("\nShutdown modes are:\n"));
1546 printf(_(" smart quit after all clients have disconnected\n"));
1547 printf(_(" fast quit directly, with proper shutdown\n"));
1548 printf(_(" immediate quit without complete shutdown; will lead to recovery on restart\n"));
1549
1550 printf(_("\nAllowed signal names for kill:\n"));
1551 printf(" HUP INT QUIT ABRT TERM USR1 USR2\n");
1552
1553 #if defined(WIN32) || defined(__CYGWIN__)
1554 printf(_("\nOptions for register and unregister:\n"));
1555 printf(_(" -N SERVICENAME service name with which to register PostgreSQL server\n"));
1556 printf(_(" -P PASSWORD password of account to register PostgreSQL server\n"));
1557 printf(_(" -U USERNAME user name of account to register PostgreSQL server\n"));
1558 #endif
1559
1560 printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
1561 }
1562
1563
1564
1565 static void
1566 set_mode(char *modeopt)
1567 {
1568 if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
1569 {
1570 shutdown_mode = SMART_MODE;
1571 sig = SIGTERM;
1572 }
1573 else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
1574 {
1575 shutdown_mode = FAST_MODE;
1576 sig = SIGINT;
1577 }
1578 else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
1579 {
1580 shutdown_mode = IMMEDIATE_MODE;
1581 sig = SIGQUIT;
1582 }
1583 else
1584 {
1585 write_stderr(_("%s: unrecognized shutdown mode \"%s\"\n"), progname, modeopt);
1586 do_advice();
1587 exit(1);
1588 }
1589 }
1590
1591
1592
1593 static void
1594 set_sig(char *signame)
1595 {
1596 if (!strcmp(signame, "HUP"))
1597 sig = SIGHUP;
1598 else if (!strcmp(signame, "INT"))
1599 sig = SIGINT;
1600 else if (!strcmp(signame, "QUIT"))
1601 sig = SIGQUIT;
1602 else if (!strcmp(signame, "ABRT"))
1603 sig = SIGABRT;
1604
1605 /*
1606 * probably should NOT provide SIGKILL
1607 *
1608 * else if (!strcmp(signame,"KILL")) sig = SIGKILL;
1609 */
1610 else if (!strcmp(signame, "TERM"))
1611 sig = SIGTERM;
1612 else if (!strcmp(signame, "USR1"))
1613 sig = SIGUSR1;
1614 else if (!strcmp(signame, "USR2"))
1615 sig = SIGUSR2;
1616 else
1617 {
1618 write_stderr(_("%s: unrecognized signal name \"%s\"\n"), progname, signame);
1619 do_advice();
1620 exit(1);
1621 }
1622
1623 }
1624
1625
1626
1627 int
1628 main(int argc, char **argv)
1629 {
1630 static struct option long_options[] = {
1631 {"help", no_argument, NULL, '?'},
1632 {"version", no_argument, NULL, 'V'},
1633 {"log", required_argument, NULL, 'l'},
1634 {"mode", required_argument, NULL, 'm'},
1635 {"pgdata", required_argument, NULL, 'D'},
1636 {"silent", no_argument, NULL, 's'},
1637 {"timeout", required_argument, NULL, 't'},
1638 {"core-files", no_argument, NULL, 'c'},
1639 {NULL, 0, NULL, 0}
1640 };
1641
1642 int option_index;
1643 int c;
1644 pgpid_t killproc = 0;
1645
1646 #if defined(WIN32) || defined(__CYGWIN__)
1647 setvbuf(stderr, NULL, _IONBF, 0);
1648 #endif
1649
1650 progname = get_progname(argv[0]);
1651 set_pglocale_pgservice(argv[0], "pg_ctl");
1652
1653 /*
1654 * save argv[0] so do_start() can look for the postmaster if necessary. we
1655 * don't look for postmaster here because in many cases we won't need it.
1656 */
1657 argv0 = argv[0];
1658
1659 umask(077);
1660
1661 /* support --help and --version even if invoked as root */
1662 if (argc > 1)
1663 {
1664 if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0 ||
1665 strcmp(argv[1], "-?") == 0)
1666 {
1667 do_help();
1668 exit(0);
1669 }
1670 else if (strcmp(argv[1], "-V") == 0 || strcmp(argv[1], "--version") == 0)
1671 {
1672 puts("pg_ctl (PostgreSQL) " PG_VERSION);
1673 exit(0);
1674 }
1675 }
1676
1677 /*
1678 * Disallow running as root, to forestall any possible security holes.
1679 */
1680 #ifndef WIN32
1681 if (geteuid() == 0)
1682 {
1683 write_stderr(_("%s: cannot be run as root\n"
1684 "Please log in (using, e.g., \"su\") as the "
1685 "(unprivileged) user that will\n"
1686 "own the server process.\n"),
1687 progname);
1688 exit(1);
1689 }
1690 #endif
1691
1692 /*
1693 * 'Action' can be before or after args so loop over both. Some
1694 * getopt_long() implementations will reorder argv[] to place all flags
1695 * first (GNU?), but we don't rely on it. Our /port version doesn't do
1696 * that.
1697 */
1698 optind = 1;
1699
1700 /* process command-line options */
1701 while (optind < argc)
1702 {
1703 while ((c = getopt_long(argc, argv, "cD:l:m:N:o:p:P:st:U:wW", long_options, &option_index)) != -1)
1704 {
1705 switch (c)
1706 {
1707 case 'D':
1708 {
1709 char *pgdata_D;
1710 char *env_var = pg_malloc(strlen(optarg) + 8);
1711
1712 pgdata_D = xstrdup(optarg);
1713 canonicalize_path(pgdata_D);
1714 snprintf(env_var, strlen(optarg) + 8, "PGDATA=%s",
1715 pgdata_D);
1716 putenv(env_var);
1717
1718 /*
1719 * We could pass PGDATA just in an environment
1720 * variable but we do -D too for clearer postmaster
1721 * 'ps' display
1722 */
1723 pgdata_opt = pg_malloc(strlen(pgdata_D) + 7);
1724 snprintf(pgdata_opt, strlen(pgdata_D) + 7,
1725 "-D \"%s\" ",
1726 pgdata_D);
1727 break;
1728 }
1729 case 'l':
1730 log_file = xstrdup(optarg);
1731 break;
1732 case 'm':
1733 set_mode(optarg);
1734 break;
1735 case 'N':
1736 register_servicename = xstrdup(optarg);
1737 break;
1738 case 'o':
1739 post_opts = xstrdup(optarg);
1740 break;
1741 case 'p':
1742 postgres_path = xstrdup(optarg);
1743 break;
1744 case 'P':
1745 register_password = xstrdup(optarg);
1746 break;
1747 case 's':
1748 silent_mode = true;
1749 break;
1750 case 't':
1751 wait_seconds = atoi(optarg);
1752 break;
1753 case 'U':
1754 if (strchr(optarg, '\\'))
1755 register_username = xstrdup(optarg);
1756 else
1757 /* Prepend .\ for local accounts */
1758 {
1759 register_username = malloc(strlen(optarg) + 3);
1760 if (!register_username)
1761 {
1762 write_stderr(_("%s: out of memory\n"), progname);
1763 exit(1);
1764 }
1765 strcpy(register_username, ".\\");
1766 strcat(register_username, optarg);
1767 }
1768 break;
1769 case 'w':
1770 do_wait = true;
1771 wait_set = true;
1772 break;
1773 case 'W':
1774 do_wait = false;
1775 wait_set = true;
1776 break;
1777 case 'c':
1778 allow_core_files = true;
1779 break;
1780 default:
1781 /* getopt_long already issued a suitable error message */
1782 do_advice();
1783 exit(1);
1784 }
1785 }
1786
1787 /* Process an action */
1788 if (optind < argc)
1789 {
1790 if (ctl_command != NO_COMMAND)
1791 {
1792 write_stderr(_("%s: too many command-line arguments (first is \"%s\")\n"), progname, argv[optind]);
1793 do_advice();
1794 exit(1);
1795 }
1796
1797 if (strcmp(argv[optind], "start") == 0)
1798 ctl_command = START_COMMAND;
1799 else if (strcmp(argv[optind], "stop") == 0)
1800 ctl_command = STOP_COMMAND;
1801 else if (strcmp(argv[optind], "restart") == 0)
1802 ctl_command = RESTART_COMMAND;
1803 else if (strcmp(argv[optind], "reload") == 0)
1804 ctl_command = RELOAD_COMMAND;
1805 else if (strcmp(argv[optind], "status") == 0)
1806 ctl_command = STATUS_COMMAND;
1807 else if (strcmp(argv[optind], "kill") == 0)
1808 {
1809 if (argc - optind < 3)
1810 {
1811 write_stderr(_("%s: missing arguments for kill mode\n"), progname);
1812 do_advice();
1813 exit(1);
1814 }
1815 ctl_command = KILL_COMMAND;
1816 set_sig(argv[++optind]);
1817 killproc = atol(argv[++optind]);
1818 }
1819 #if defined(WIN32) || defined(__CYGWIN__)
1820 else if (strcmp(argv[optind], "register") == 0)
1821 ctl_command = REGISTER_COMMAND;
1822 else if (strcmp(argv[optind], "unregister") == 0)
1823 ctl_command = UNREGISTER_COMMAND;
1824 else if (strcmp(argv[optind], "runservice") == 0)
1825 ctl_command = RUN_AS_SERVICE_COMMAND;
1826 #endif
1827 else
1828 {
1829 write_stderr(_("%s: unrecognized operation mode \"%s\"\n"), progname, argv[optind]);
1830 do_advice();
1831 exit(1);
1832 }
1833 optind++;
1834 }
1835 }
1836
1837 if (ctl_command == NO_COMMAND)
1838 {
1839 write_stderr(_("%s: no operation specified\n"), progname);
1840 do_advice();
1841 exit(1);
1842 }
1843
1844 /* Note we put any -D switch into the env var above */
1845 pg_data = getenv("PGDATA");
1846 if (pg_data)
1847 {
1848 pg_data = xstrdup(pg_data);
1849 canonicalize_path(pg_data);
1850 }
1851
1852 if (pg_data == NULL &&
1853 ctl_command != KILL_COMMAND && ctl_command != UNREGISTER_COMMAND)
1854 {
1855 write_stderr(_("%s: no database directory specified "
1856 "and environment variable PGDATA unset\n"),
1857 progname);
1858 do_advice();
1859 exit(1);
1860 }
1861
1862 if (!wait_set)
1863 {
1864 switch (ctl_command)
1865 {
1866 case RESTART_COMMAND:
1867 case START_COMMAND:
1868 do_wait = false;
1869 break;
1870 case STOP_COMMAND:
1871 do_wait = true;
1872 break;
1873 default:
1874 break;
1875 }
1876 }
1877
1878 if (ctl_command == RELOAD_COMMAND)
1879 {
1880 sig = SIGHUP;
1881 do_wait = false;
1882 }
1883
1884 if (pg_data)
1885 {
1886 snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
1887 snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
1888 snprintf(conf_file, MAXPGPATH, "%s/postgresql.conf", pg_data);
1889 snprintf(backup_file, MAXPGPATH, "%s/backup_label", pg_data);
1890 }
1891
1892 switch (ctl_command)
1893 {
1894 case STATUS_COMMAND:
1895 do_status();
1896 break;
1897 case START_COMMAND:
1898 do_start();
1899 break;
1900 case STOP_COMMAND:
1901 do_stop();
1902 break;
1903 case RESTART_COMMAND:
1904 do_restart();
1905 break;
1906 case RELOAD_COMMAND:
1907 do_reload();
1908 break;
1909 case KILL_COMMAND:
1910 do_kill(killproc);
1911 break;
1912 #if defined(WIN32) || defined(__CYGWIN__)
1913 case REGISTER_COMMAND:
1914 pgwin32_doRegister();
1915 break;
1916 case UNREGISTER_COMMAND:
1917 pgwin32_doUnregister();
1918 break;
1919 case RUN_AS_SERVICE_COMMAND:
1920 pgwin32_doRunAsService();
1921 break;
1922 #endif
1923 default:
1924 break;
1925 }
1926
1927 exit(0);
1928 }
PostgreSQL from CVS