pg_ctl.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * pg_ctl --- start/stops/restarts the PostgreSQL server
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 *
 * src/bin/pg_ctl/pg_ctl.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres_fe.h"
 
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <unistd.h>
 
 
#include "catalog/pg_control.h"
#include "common/controldata_utils.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "common/string.h"
#include "datatype/timestamp.h"
#include "getopt_long.h"
#include "utils/pidfile.h"
 
#ifdef WIN32                    /* on Unix, we don't need libpq */
#include "pqexpbuffer.h"
#endif
 
 
typedef enum
{
    SMART_MODE,
    FAST_MODE,
    IMMEDIATE_MODE,
} ShutdownMode;
 
typedef enum
{
    POSTMASTER_READY,
    POSTMASTER_STILL_STARTING,
    POSTMASTER_SHUTDOWN_IN_RECOVERY,
    POSTMASTER_FAILED,
} WaitPMResult;
 
typedef enum
{
    NO_COMMAND = 0,
    INIT_COMMAND,
    START_COMMAND,
    STOP_COMMAND,
    RESTART_COMMAND,
    RELOAD_COMMAND,
    STATUS_COMMAND,
    PROMOTE_COMMAND,
    LOGROTATE_COMMAND,
    KILL_COMMAND,
    REGISTER_COMMAND,
    UNREGISTER_COMMAND,
    RUN_AS_SERVICE_COMMAND,
} CtlCommand;
 
#define DEFAULT_WAIT    60
 
#define WAITS_PER_SEC   10
StaticAssertDecl(USECS_PER_SEC % WAITS_PER_SEC == 0,
                 "WAITS_PER_SEC must divide USECS_PER_SEC evenly");
 
static bool do_wait = true;
static int  wait_seconds = DEFAULT_WAIT;
static bool wait_seconds_arg = false;
static bool silent_mode = false;
static ShutdownMode shutdown_mode = FAST_MODE;
static int  sig = SIGINT;       /* default */
static CtlCommand ctl_command = NO_COMMAND;
static char *pg_data = NULL;
static char *pg_config = NULL;
static char *pgdata_opt = NULL;
static char *post_opts = NULL;
static const char *progname;
static char *log_file = NULL;
static char *exec_path = NULL;
static char *event_source = NULL;
static char *register_servicename = "PostgreSQL";   /* FIXME: + version ID? */
static char *register_username = NULL;
static char *register_password = NULL;
static char *argv0 = NULL;
static bool allow_core_files = false;
static time_t start_time;
 
static char postopts_file[MAXPGPATH];
static char version_file[MAXPGPATH];
static char pid_file[MAXPGPATH];
static char promote_file[MAXPGPATH];
static char logrotate_file[MAXPGPATH];
 
static volatile pid_t postmasterPID = -1;
 
#ifdef WIN32
static DWORD pgctl_start_type = SERVICE_AUTO_START;
static SERVICE_STATUS status;
static SERVICE_STATUS_HANDLE hStatus = (SERVICE_STATUS_HANDLE) 0;
static HANDLE shutdownHandles[2];
 
#define shutdownEvent     shutdownHandles[0]
#define postmasterProcess shutdownHandles[1]
#endif
 
 
static void write_stderr(const char *fmt,...) pg_attribute_printf(1, 2);
static void do_advice(void);
static void do_help(void);
static void set_mode(char *modeopt);
static void set_sig(char *signame);
static void do_init(void);
static void do_start(void);
static void do_stop(void);
static void do_restart(void);
static void do_reload(void);
static void do_status(void);
static void do_promote(void);
static void do_logrotate(void);
static void do_kill(pid_t pid);
static void print_msg(const char *msg);
static void adjust_data_dir(void);
 
#ifdef WIN32
#include <versionhelpers.h>
static bool pgwin32_IsInstalled(SC_HANDLE);
static char *pgwin32_CommandLine(bool);
static void pgwin32_doRegister(void);
static void pgwin32_doUnregister(void);
static void pgwin32_SetServiceStatus(DWORD);
static void WINAPI pgwin32_ServiceHandler(DWORD);
static void WINAPI pgwin32_ServiceMain(DWORD, LPTSTR *);
static void pgwin32_doRunAsService(void);
static int  CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service);
static PTOKEN_PRIVILEGES GetPrivilegesToDelete(HANDLE hToken);
#endif
 
static pid_t get_pgpid(bool is_status_request);
static char **readfile(const char *path, int *numlines);
static void free_readfile(char **optlines);
static pid_t start_postmaster(void);
static void read_post_opts(void);
 
static WaitPMResult wait_for_postmaster_start(pid_t pm_pid, bool do_checkpoint);
static bool wait_for_postmaster_stop(void);
static bool wait_for_postmaster_promote(void);
static bool postmaster_is_alive(pid_t pid);
 
#if defined(HAVE_GETRLIMIT)
static void unlimit_core_size(void);
#endif
 
static DBState get_control_dbstate(void);
 
 
#ifdef WIN32
static void
write_eventlog(int level, const char *line)
{
    static HANDLE evtHandle = INVALID_HANDLE_VALUE;
 
    if (silent_mode && level == EVENTLOG_INFORMATION_TYPE)
        return;
 
    if (evtHandle == INVALID_HANDLE_VALUE)
    {
        evtHandle = RegisterEventSource(NULL,
                                        event_source ? event_source : DEFAULT_EVENT_SOURCE);
        if (evtHandle == NULL)
        {
            evtHandle = INVALID_HANDLE_VALUE;
            return;
        }
    }
 
    ReportEvent(evtHandle,
                level,
                0,
                0,              /* All events are Id 0 */
                NULL,
                1,
                0,
                &line,
                NULL);
}
#endif
 
/*
 * Write errors to stderr (or by equal means when stderr is
 * not available).
 */
static void
write_stderr(const char *fmt,...)
{
    va_list     ap;
 
    va_start(ap, fmt);
#ifndef WIN32
    /* On Unix, we just fprintf to stderr */
    vfprintf(stderr, fmt, ap);
#else
 
    /*
     * On Win32, we print to stderr if running on a console, or write to
     * eventlog if running as a service
     */
    if (pgwin32_is_service())   /* Running as a service */
    {
        char        errbuf[2048];   /* Arbitrary size? */
 
        vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
 
        write_eventlog(EVENTLOG_ERROR_TYPE, errbuf);
    }
    else
        /* Not running as service, write to stderr */
        vfprintf(stderr, fmt, ap);
#endif
    va_end(ap);
}
 
/*
 * Given an already-localized string, print it to stdout unless the
 * user has specified that no messages should be printed.
 */
static void
print_msg(const char *msg)
{
    if (!silent_mode)
    {
        fputs(msg, stdout);
        fflush(stdout);
    }
}
 
static pid_t
get_pgpid(bool is_status_request)
{
    FILE       *pidf;
    int         pid;
    struct stat statbuf;
 
    if (stat(pg_data, &statbuf) != 0)
    {
        if (errno == ENOENT)
            write_stderr(_("%s: directory \"%s\" does not exist\n"), progname,
                         pg_data);
        else
            write_stderr(_("%s: could not access directory \"%s\": %m\n"), progname,
                         pg_data);
 
        /*
         * The Linux Standard Base Core Specification 3.1 says this should
         * return '4, program or service status is unknown'
         * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
         */
        exit(is_status_request ? 4 : 1);
    }
 
    if (stat(version_file, &statbuf) != 0 && errno == ENOENT)
    {
        write_stderr(_("%s: directory \"%s\" is not a database cluster directory\n"),
                     progname, pg_data);
        exit(is_status_request ? 4 : 1);
    }
 
    pidf = fopen(pid_file, "r");
    if (pidf == NULL)
    {
        /* No pid file, not an error on startup */
        if (errno == ENOENT)
            return 0;
        else
        {
            write_stderr(_("%s: could not open PID file \"%s\": %m\n"),
                         progname, pid_file);
            exit(1);
        }
    }
    if (fscanf(pidf, "%d", &pid) != 1)
    {
        /* Is the file empty? */
        if (ftell(pidf) == 0 && feof(pidf))
            write_stderr(_("%s: the PID file \"%s\" is empty\n"),
                         progname, pid_file);
        else
            write_stderr(_("%s: invalid data in PID file \"%s\"\n"),
                         progname, pid_file);
        exit(1);
    }
    fclose(pidf);
    return (pid_t) pid;
}
 
 
/*
 * get the lines from a text file - return NULL if file can't be opened
 *
 * Trailing newlines are deleted from the lines (this is a change from pre-v10)
 *
 * *numlines is set to the number of line pointers returned; there is
 * also an additional NULL pointer after the last real line.
 */
static char **
readfile(const char *path, int *numlines)
{
    int         fd;
    int         nlines;
    char      **result;
    char       *buffer;
    char       *linebegin;
    int         i;
    int         n;
    int         len;
    struct stat statbuf;
 
    *numlines = 0;              /* in case of failure or empty file */
 
    /*
     * Slurp the file into memory.
     *
     * The file can change concurrently, so we read the whole file into memory
     * with a single read() call. That's not guaranteed to get an atomic
     * snapshot, but in practice, for a small file, it's close enough for the
     * current use.
     */
    fd = open(path, O_RDONLY | PG_BINARY, 0);
    if (fd < 0)
        return NULL;
    if (fstat(fd, &statbuf) < 0)
    {
        close(fd);
        return NULL;
    }
    if (statbuf.st_size == 0)
    {
        /* empty file */
        close(fd);
        result = (char **) pg_malloc(sizeof(char *));
        *result = NULL;
        return result;
    }
    buffer = pg_malloc(statbuf.st_size + 1);
 
    len = read(fd, buffer, statbuf.st_size + 1);
    close(fd);
    if (len != statbuf.st_size)
    {
        /* oops, the file size changed between fstat and read */
        free(buffer);
        return NULL;
    }
 
    /*
     * Count newlines. We expect there to be a newline after each full line,
     * including one at the end of file. If there isn't a newline at the end,
     * any characters after the last newline will be ignored.
     */
    nlines = 0;
    for (i = 0; i < len; i++)
    {
        if (buffer[i] == '\n')
            nlines++;
    }
 
    /* set up the result buffer */
    result = (char **) pg_malloc((nlines + 1) * sizeof(char *));
    *numlines = nlines;
 
    /* now split the buffer into lines */
    linebegin = buffer;
    n = 0;
    for (i = 0; i < len; i++)
    {
        if (buffer[i] == '\n')
        {
            int         slen = &buffer[i] - linebegin;
            char       *linebuf = pg_malloc(slen + 1);
 
            memcpy(linebuf, linebegin, slen);
            /* we already dropped the \n, but get rid of any \r too */
            if (slen > 0 && linebuf[slen - 1] == '\r')
                slen--;
            linebuf[slen] = '\0';
            result[n++] = linebuf;
            linebegin = &buffer[i + 1];
        }
    }
    result[n] = NULL;
 
    free(buffer);
 
    return result;
}
 
 
/*
 * Free memory allocated for optlines through readfile()
 */
static void
free_readfile(char **optlines)
{
    char       *curr_line = NULL;
    int         i = 0;
 
    if (!optlines)
        return;
 
    while ((curr_line = optlines[i++]))
        free(curr_line);
 
    free(optlines);
}
 
/*
 * start/test/stop routines
 */
 
/*
 * Start the postmaster and return its PID.
 *
 * Currently, on Windows what we return is the PID of the shell process
 * that launched the postmaster (and, we trust, is waiting for it to exit).
 * So the PID is usable for "is the postmaster still running" checks,
 * but cannot be compared directly to postmaster.pid.
 *
 * On Windows, we also save aside a handle to the shell process in
 * "postmasterProcess", which the caller should close when done with it.
 */
static pid_t
start_postmaster(void)
{
    char       *cmd;
 
#ifndef WIN32
    pid_t       pm_pid;
 
    /* Flush stdio channels just before fork, to avoid double-output problems */
    fflush(NULL);
 
#ifdef EXEC_BACKEND
    pg_disable_aslr();
#endif
 
    pm_pid = fork();
    if (pm_pid < 0)
    {
        /* fork failed */
        write_stderr(_("%s: could not start server: %m\n"),
                     progname);
        exit(1);
    }
    if (pm_pid > 0)
    {
        /* fork succeeded, in parent */
        return pm_pid;
    }
 
    /* fork succeeded, in child */
 
    /*
     * If possible, detach the postmaster process from the launching process
     * group and make it a group leader, so that it doesn't get signaled along
     * with the current group that launched it.
     */
#ifdef HAVE_SETSID
    if (setsid() < 0)
    {
        write_stderr(_("%s: could not start server due to setsid() failure: %m\n"),
                     progname);
        exit(1);
    }
#endif
 
    /*
     * Since there might be quotes to handle here, it is easier simply to pass
     * everything to a shell to process them.  Use exec so that the postmaster
     * has the same PID as the current child process.
     */
    if (log_file != NULL)
        cmd = psprintf("exec \"%s\" %s%s < \"%s\" >> \"%s\" 2>&1",
                       exec_path, pgdata_opt, post_opts,
                       DEVNULL, log_file);
    else
        cmd = psprintf("exec \"%s\" %s%s < \"%s\" 2>&1",
                       exec_path, pgdata_opt, post_opts, DEVNULL);
 
    (void) execl("/bin/sh", "/bin/sh", "-c", cmd, (char *) NULL);
 
    /* exec failed */
    write_stderr(_("%s: could not start server: %m\n"),
                 progname);
    exit(1);
 
    return 0;                   /* keep dumb compilers quiet */
 
#else                           /* WIN32 */
 
    /*
     * As with the Unix case, it's easiest to use the shell (CMD.EXE) to
     * handle redirection etc.  Unfortunately CMD.EXE lacks any equivalent of
     * "exec", so we don't get to find out the postmaster's PID immediately.
     */
    PROCESS_INFORMATION pi;
    const char *comspec;
 
    /* Find CMD.EXE location using COMSPEC, if it's set */
    comspec = getenv("COMSPEC");
    if (comspec == NULL)
        comspec = "CMD";
 
    if (log_file != NULL)
    {
        /*
         * First, open the log file if it exists.  The idea is that if the
         * file is still locked by a previous postmaster run, we'll wait until
         * it comes free, instead of failing with ERROR_SHARING_VIOLATION.
         * (It'd be better to open the file in a sharing-friendly mode, but we
         * can't use CMD.EXE to do that, so work around it.  Note that the
         * previous postmaster will still have the file open for a short time
         * after removing postmaster.pid.)
         *
         * If the log file doesn't exist, we *must not* create it here.  If we
         * were launched with higher privileges than the restricted process
         * will have, the log file might end up with permissions settings that
         * prevent the postmaster from writing on it.
         */
        int         fd = open(log_file, O_RDWR, 0);
 
        if (fd == -1)
        {
            /*
             * ENOENT is expectable since we didn't use O_CREAT.  Otherwise
             * complain.  We could just fall through and let CMD.EXE report
             * the problem, but its error reporting is pretty miserable.
             */
            if (errno != ENOENT)
            {
                write_stderr(_("%s: could not open log file \"%s\": %m\n"),
                             progname, log_file);
                exit(1);
            }
        }
        else
            close(fd);
 
        cmd = psprintf("\"%s\" /C \"\"%s\" %s%s < \"%s\" >> \"%s\" 2>&1\"",
                       comspec, exec_path, pgdata_opt, post_opts, DEVNULL, log_file);
    }
    else
        cmd = psprintf("\"%s\" /C \"\"%s\" %s%s < \"%s\" 2>&1\"",
                       comspec, exec_path, pgdata_opt, post_opts, DEVNULL);
 
    if (!CreateRestrictedProcess(cmd, &pi, false))
    {
        write_stderr(_("%s: could not start server: error code %lu\n"),
                     progname, GetLastError());
        exit(1);
    }
    /* Don't close command process handle here; caller must do so */
    postmasterProcess = pi.hProcess;
    CloseHandle(pi.hThread);
    return pi.dwProcessId;      /* Shell's PID, not postmaster's! */
#endif                          /* WIN32 */
}
 
 
 
/*
 * Wait for the postmaster to become ready.
 *
 * On Unix, pm_pid is the PID of the just-launched postmaster.  On Windows,
 * it may be the PID of an ancestor shell process, so we can't check the
 * contents of postmaster.pid quite as carefully.
 *
 * On Windows, the static variable postmasterProcess is an implicit argument
 * to this routine; it contains a handle to the postmaster process or an
 * ancestor shell process thereof.
 *
 * Note that the checkpoint parameter enables a Windows service control
 * manager checkpoint, it's got nothing to do with database checkpoints!!
 */
static WaitPMResult
wait_for_postmaster_start(pid_t pm_pid, bool do_checkpoint)
{
    int         i;
 
    for (i = 0; i < wait_seconds * WAITS_PER_SEC; i++)
    {
        char      **optlines;
        int         numlines;
 
        /*
         * Try to read the postmaster.pid file.  If it's not valid, or if the
         * status line isn't there yet, just keep waiting.
         */
        if ((optlines = readfile(pid_file, &numlines)) != NULL &&
            numlines >= LOCK_FILE_LINE_PM_STATUS)
        {
            /* File is complete enough for us, parse it */
            pid_t       pmpid;
            time_t      pmstart;
 
            /*
             * Make sanity checks.  If it's for the wrong PID, or the recorded
             * start time is before pg_ctl started, then either we are looking
             * at the wrong data directory, or this is a pre-existing pidfile
             * that hasn't (yet?) been overwritten by our child postmaster.
             * Allow 2 seconds slop for possible cross-process clock skew.
             */
            pmpid = atol(optlines[LOCK_FILE_LINE_PID - 1]);
            pmstart = atoll(optlines[LOCK_FILE_LINE_START_TIME - 1]);
            if (pmstart >= start_time - 2 &&
#ifndef WIN32
                pmpid == pm_pid
#else
            /* Windows can only reject standalone-backend PIDs */
                pmpid > 0
#endif
                )
            {
                /*
                 * OK, seems to be a valid pidfile from our child.  Check the
                 * status line (this assumes a v10 or later server).
                 */
                char       *pmstatus = optlines[LOCK_FILE_LINE_PM_STATUS - 1];
 
                if (strcmp(pmstatus, PM_STATUS_READY) == 0 ||
                    strcmp(pmstatus, PM_STATUS_STANDBY) == 0)
                {
                    /* postmaster is done starting up */
                    free_readfile(optlines);
                    return POSTMASTER_READY;
                }
            }
        }
 
        /*
         * Free the results of readfile.
         *
         * This is safe to call even if optlines is NULL.
         */
        free_readfile(optlines);
 
        /*
         * Check whether the child postmaster process is still alive.  This
         * lets us exit early if the postmaster fails during startup.
         *
         * On Windows, we may be checking the postmaster's parent shell, but
         * that's fine for this purpose.
         */
        {
            bool        pm_died;
#ifndef WIN32
            int         exitstatus;
 
            pm_died = (waitpid(pm_pid, &exitstatus, WNOHANG) == pm_pid);
#else
            pm_died = (WaitForSingleObject(postmasterProcess, 0) == WAIT_OBJECT_0);
#endif
            if (pm_died)
            {
                /* See if postmaster terminated intentionally */
                if (get_control_dbstate() == DB_SHUTDOWNED_IN_RECOVERY)
                    return POSTMASTER_SHUTDOWN_IN_RECOVERY;
                else
                    return POSTMASTER_FAILED;
            }
        }
 
        /* Startup still in process; wait, printing a dot once per second */
        if (i % WAITS_PER_SEC == 0)
        {
#ifdef WIN32
            if (do_checkpoint)
            {
                /*
                 * Increment the wait hint by 6 secs (connection timeout +
                 * sleep).  We must do this to indicate to the SCM that our
                 * startup time is changing, otherwise it'll usually send a
                 * stop signal after 20 seconds, despite incrementing the
                 * checkpoint counter.
                 */
                status.dwWaitHint += 6000;
                status.dwCheckPoint++;
                SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
            }
            else
#endif
                print_msg(".");
        }
 
        pg_usleep(USECS_PER_SEC / WAITS_PER_SEC);
    }
 
    /* out of patience; report that postmaster is still starting up */
    return POSTMASTER_STILL_STARTING;
}
 
 
/*
 * Wait for the postmaster to stop.
 *
 * Returns true if the postmaster stopped cleanly (i.e., removed its pidfile).
 * Returns false if the postmaster dies uncleanly, or if we time out.
 */
static bool
wait_for_postmaster_stop(void)
{
    int         cnt;
 
    for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
    {
        pid_t       pid;
 
        if ((pid = get_pgpid(false)) == 0)
            return true;        /* pid file is gone */
 
        if (kill(pid, 0) != 0)
        {
            /*
             * Postmaster seems to have died.  Check the pid file once more to
             * avoid a race condition, but give up waiting.
             */
            if (get_pgpid(false) == 0)
                return true;    /* pid file is gone */
            return false;       /* postmaster died untimely */
        }
 
        if (cnt % WAITS_PER_SEC == 0)
            print_msg(".");
        pg_usleep(USECS_PER_SEC / WAITS_PER_SEC);
    }
    return false;               /* timeout reached */
}
 
 
/*
 * Wait for the postmaster to promote.
 *
 * Returns true on success, else false.
 * To avoid waiting uselessly, we check for postmaster death here too.
 */
static bool
wait_for_postmaster_promote(void)
{
    int         cnt;
 
    for (cnt = 0; cnt < wait_seconds * WAITS_PER_SEC; cnt++)
    {
        pid_t       pid;
        DBState     state;
 
        if ((pid = get_pgpid(false)) == 0)
            return false;       /* pid file is gone */
        if (kill(pid, 0) != 0)
            return false;       /* postmaster died */
 
        state = get_control_dbstate();
        if (state == DB_IN_PRODUCTION)
            return true;        /* successful promotion */
 
        if (cnt % WAITS_PER_SEC == 0)
            print_msg(".");
        pg_usleep(USECS_PER_SEC / WAITS_PER_SEC);
    }
    return false;               /* timeout reached */
}
 
 
#if defined(HAVE_GETRLIMIT)
static void
unlimit_core_size(void)
{
    struct rlimit lim;
 
    getrlimit(RLIMIT_CORE, &lim);
    if (lim.rlim_max == 0)
    {
        write_stderr(_("%s: cannot set core file size limit; disallowed by hard limit\n"),
                     progname);
        return;
    }
    else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
    {
        lim.rlim_cur = lim.rlim_max;
        setrlimit(RLIMIT_CORE, &lim);
    }
}
#endif
 
static void
read_post_opts(void)
{
    if (post_opts == NULL)
    {
        post_opts = "";         /* default */
        if (ctl_command == RESTART_COMMAND)
        {
            char      **optlines;
            int         numlines;
 
            optlines = readfile(postopts_file, &numlines);
            if (optlines == NULL)
            {
                write_stderr(_("%s: could not read file \"%s\"\n"), progname, postopts_file);
                exit(1);
            }
            else if (numlines != 1)
            {
                write_stderr(_("%s: option file \"%s\" must have exactly one line\n"),
                             progname, postopts_file);
                exit(1);
            }
            else
            {
                char       *optline;
                char       *arg1;
 
                optline = optlines[0];
 
                /*
                 * Are we at the first option, as defined by space and
                 * double-quote?
                 */
                if ((arg1 = strstr(optline, " \"")) != NULL)
                {
                    *arg1 = '\0';   /* terminate so we get only program name */
                    post_opts = pg_strdup(arg1 + 1);    /* point past whitespace */
                }
                if (exec_path == NULL)
                    exec_path = pg_strdup(optline);
            }
 
            /* Free the results of readfile. */
            free_readfile(optlines);
        }
    }
}
 
/*
 * SIGINT signal handler used while waiting for postmaster to start up.
 * Forwards the SIGINT to the postmaster process, asking it to shut down,
 * before terminating pg_ctl itself. This way, if the user hits CTRL-C while
 * waiting for the server to start up, the server launch is aborted.
 */
static void
trap_sigint_during_startup(SIGNAL_ARGS)
{
    if (postmasterPID != -1)
    {
        if (kill(postmasterPID, SIGINT) != 0)
            write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"),
                         progname, (int) postmasterPID);
    }
 
    /*
     * Clear the signal handler, and send the signal again, to terminate the
     * process as normal.
     */
    pqsignal(postgres_signal_arg, SIG_DFL);
    raise(postgres_signal_arg);
}
 
static char *
find_other_exec_or_die(const char *argv0, const char *target, const char *versionstr)
{
    int         ret;
    char       *found_path;
 
    found_path = pg_malloc(MAXPGPATH);
 
    if ((ret = find_other_exec(argv0, target, versionstr, found_path)) < 0)
    {
        char        full_path[MAXPGPATH];
 
        if (find_my_exec(argv0, full_path) < 0)
            strlcpy(full_path, progname, sizeof(full_path));
 
        if (ret == -1)
            write_stderr(_("program \"%s\" is needed by %s but was not found in the same directory as \"%s\"\n"),
                         target, progname, full_path);
        else
            write_stderr(_("program \"%s\" was found by \"%s\" but was not the same version as %s\n"),
                         target, full_path, progname);
        exit(1);
    }
 
    return found_path;
}
 
static void
do_init(void)
{
    char       *cmd;
 
    if (exec_path == NULL)
        exec_path = find_other_exec_or_die(argv0, "initdb", "initdb (PostgreSQL) " PG_VERSION "\n");
 
    if (pgdata_opt == NULL)
        pgdata_opt = "";
 
    if (post_opts == NULL)
        post_opts = "";
 
    if (!silent_mode)
        cmd = psprintf("\"%s\" %s%s",
                       exec_path, pgdata_opt, post_opts);
    else
        cmd = psprintf("\"%s\" %s%s > \"%s\"",
                       exec_path, pgdata_opt, post_opts, DEVNULL);
 
    fflush(NULL);
    if (system(cmd) != 0)
    {
        write_stderr(_("%s: database system initialization failed\n"), progname);
        exit(1);
    }
}
 
static void
do_start(void)
{
    pid_t       old_pid = 0;
    pid_t       pm_pid;
 
    if (ctl_command != RESTART_COMMAND)
    {
        old_pid = get_pgpid(false);
        if (old_pid != 0)
            write_stderr(_("%s: another server might be running; "
                           "trying to start server anyway\n"),
                         progname);
    }
 
    read_post_opts();
 
    /* No -D or -D already added during server start */
    if (ctl_command == RESTART_COMMAND || pgdata_opt == NULL)
        pgdata_opt = "";
 
    if (exec_path == NULL)
        exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);
 
#if defined(HAVE_GETRLIMIT)
    if (allow_core_files)
        unlimit_core_size();
#endif
 
    /*
     * If possible, tell the postmaster our parent shell's PID (see the
     * comments in CreateLockFile() for motivation).  Windows hasn't got
     * getppid() unfortunately.
     */
#ifndef WIN32
    {
        char        env_var[32];
 
        snprintf(env_var, sizeof(env_var), "%d", (int) getppid());
        setenv("PG_GRANDPARENT_PID", env_var, 1);
    }
#endif
 
    pm_pid = start_postmaster();
 
    if (do_wait)
    {
        /*
         * If the user interrupts the startup (e.g. with CTRL-C), we'd like to
         * abort the server launch.  Install a signal handler that will
         * forward SIGINT to the postmaster process, while we wait.
         *
         * (We don't bother to reset the signal handler after the launch, as
         * we're about to exit, anyway.)
         */
        postmasterPID = pm_pid;
        pqsignal(SIGINT, trap_sigint_during_startup);
 
        print_msg(_("waiting for server to start..."));
 
        switch (wait_for_postmaster_start(pm_pid, false))
        {
            case POSTMASTER_READY:
                print_msg(_(" done\n"));
                print_msg(_("server started\n"));
                break;
            case POSTMASTER_STILL_STARTING:
                print_msg(_(" stopped waiting\n"));
                write_stderr(_("%s: server did not start in time\n"),
                             progname);
                exit(1);
                break;
            case POSTMASTER_SHUTDOWN_IN_RECOVERY:
                print_msg(_(" done\n"));
                print_msg(_("server shut down because of recovery target settings\n"));
                break;
            case POSTMASTER_FAILED:
                print_msg(_(" stopped waiting\n"));
                write_stderr(_("%s: could not start server\n"
                               "Examine the log output.\n"),
                             progname);
                exit(1);
                break;
        }
    }
    else
        print_msg(_("server starting\n"));
 
#ifdef WIN32
    /* Now we don't need the handle to the shell process anymore */
    CloseHandle(postmasterProcess);
    postmasterProcess = INVALID_HANDLE_VALUE;
#endif
}
 
 
static void
do_stop(void)
{
    pid_t       pid;
 
    pid = get_pgpid(false);
 
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot stop server; "
                       "single-user server is running (PID: %d)\n"),
                     progname, (int) pid);
        exit(1);
    }
 
    if (kill(pid, sig) != 0)
    {
        write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
        exit(1);
    }
 
    if (!do_wait)
    {
        print_msg(_("server shutting down\n"));
        return;
    }
    else
    {
        print_msg(_("waiting for server to shut down..."));
 
        if (!wait_for_postmaster_stop())
        {
            print_msg(_(" failed\n"));
 
            write_stderr(_("%s: server does not shut down\n"), progname);
            if (shutdown_mode == SMART_MODE)
                write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
                               "waiting for session-initiated disconnection.\n"));
            exit(1);
        }
        print_msg(_(" done\n"));
 
        print_msg(_("server stopped\n"));
    }
}
 
 
/*
 *  restart/reload routines
 */
 
static void
do_restart(void)
{
    pid_t       pid;
 
    pid = get_pgpid(false);
 
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"),
                     progname, pid_file);
        write_stderr(_("Is server running?\n"));
        write_stderr(_("trying to start server anyway\n"));
        do_start();
        return;
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        if (postmaster_is_alive(pid))
        {
            write_stderr(_("%s: cannot restart server; "
                           "single-user server is running (PID: %d)\n"),
                         progname, (int) pid);
            write_stderr(_("Please terminate the single-user server and try again.\n"));
            exit(1);
        }
    }
 
    if (postmaster_is_alive(pid))
    {
        if (kill(pid, sig) != 0)
        {
            write_stderr(_("%s: could not send stop signal (PID: %d): %m\n"), progname, (int) pid);
            exit(1);
        }
 
        print_msg(_("waiting for server to shut down..."));
 
        /* always wait for restart */
        if (!wait_for_postmaster_stop())
        {
            print_msg(_(" failed\n"));
 
            write_stderr(_("%s: server does not shut down\n"), progname);
            if (shutdown_mode == SMART_MODE)
                write_stderr(_("HINT: The \"-m fast\" option immediately disconnects sessions rather than\n"
                               "waiting for session-initiated disconnection.\n"));
            exit(1);
        }
 
        print_msg(_(" done\n"));
        print_msg(_("server stopped\n"));
    }
    else
    {
        write_stderr(_("%s: old server process (PID: %d) seems to be gone\n"),
                     progname, (int) pid);
        write_stderr(_("starting server anyway\n"));
    }
 
    do_start();
}
 
static void
do_reload(void)
{
    pid_t       pid;
 
    pid = get_pgpid(false);
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot reload server; "
                       "single-user server is running (PID: %d)\n"),
                     progname, (int) pid);
        write_stderr(_("Please terminate the single-user server and try again.\n"));
        exit(1);
    }
 
    if (kill(pid, sig) != 0)
    {
        write_stderr(_("%s: could not send reload signal (PID: %d): %m\n"),
                     progname, (int) pid);
        exit(1);
    }
 
    print_msg(_("server signaled\n"));
}
 
 
/*
 * promote
 */
 
static void
do_promote(void)
{
    FILE       *prmfile;
    pid_t       pid;
 
    pid = get_pgpid(false);
 
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot promote server; "
                       "single-user server is running (PID: %d)\n"),
                     progname, (int) pid);
        exit(1);
    }
 
    if (get_control_dbstate() != DB_IN_ARCHIVE_RECOVERY)
    {
        write_stderr(_("%s: cannot promote server; "
                       "server is not in standby mode\n"),
                     progname);
        exit(1);
    }
 
    snprintf(promote_file, MAXPGPATH, "%s/promote", pg_data);
 
    if ((prmfile = fopen(promote_file, "w")) == NULL)
    {
        write_stderr(_("%s: could not create promote signal file \"%s\": %m\n"),
                     progname, promote_file);
        exit(1);
    }
    if (fclose(prmfile))
    {
        write_stderr(_("%s: could not write promote signal file \"%s\": %m\n"),
                     progname, promote_file);
        exit(1);
    }
 
    sig = SIGUSR1;
    if (kill(pid, sig) != 0)
    {
        write_stderr(_("%s: could not send promote signal (PID: %d): %m\n"),
                     progname, (int) pid);
        if (unlink(promote_file) != 0)
            write_stderr(_("%s: could not remove promote signal file \"%s\": %m\n"),
                         progname, promote_file);
        exit(1);
    }
 
    if (do_wait)
    {
        print_msg(_("waiting for server to promote..."));
        if (wait_for_postmaster_promote())
        {
            print_msg(_(" done\n"));
            print_msg(_("server promoted\n"));
        }
        else
        {
            print_msg(_(" stopped waiting\n"));
            write_stderr(_("%s: server did not promote in time\n"),
                         progname);
            exit(1);
        }
    }
    else
        print_msg(_("server promoting\n"));
}
 
/*
 * log rotate
 */
 
static void
do_logrotate(void)
{
    FILE       *logrotatefile;
    pid_t       pid;
 
    pid = get_pgpid(false);
 
    if (pid == 0)               /* no pid file */
    {
        write_stderr(_("%s: PID file \"%s\" does not exist\n"), progname, pid_file);
        write_stderr(_("Is server running?\n"));
        exit(1);
    }
    else if (pid < 0)           /* standalone backend, not postmaster */
    {
        pid = -pid;
        write_stderr(_("%s: cannot rotate log file; "
                       "single-user server is running (PID: %d)\n"),
                     progname, (int) pid);
        exit(1);
    }
 
    snprintf(logrotate_file, MAXPGPATH, "%s/logrotate", pg_data);
 
    if ((logrotatefile = fopen(logrotate_file, "w")) == NULL)
    {
        write_stderr(_("%s: could not create log rotation signal file \"%s\": %m\n"),
                     progname, logrotate_file);
        exit(1);
    }
    if (fclose(logrotatefile))
    {
        write_stderr(_("%s: could not write log rotation signal file \"%s\": %m\n"),
                     progname, logrotate_file);
        exit(1);
    }
 
    sig = SIGUSR1;
    if (kill(pid, sig) != 0)
    {
        write_stderr(_("%s: could not send log rotation signal (PID: %d): %m\n"),
                     progname, (int) pid);
        if (unlink(logrotate_file) != 0)
            write_stderr(_("%s: could not remove log rotation signal file \"%s\": %m\n"),
                         progname, logrotate_file);
        exit(1);
    }
 
    print_msg(_("server signaled to rotate log file\n"));
}
 
 
/*
 *  utility routines
 */
 
static bool
postmaster_is_alive(pid_t pid)
{
    /*
     * Test to see if the process is still there.  Note that we do not
     * consider an EPERM failure to mean that the process is still there;
     * EPERM must mean that the given PID belongs to some other userid, and
     * considering the permissions on $PGDATA, that means it's not the
     * postmaster we are after.
     *
     * Don't believe that our own PID or parent shell's PID is the postmaster,
     * either.  (Windows hasn't got getppid(), though.)
     */
    if (pid == getpid())
        return false;
#ifndef WIN32
    if (pid == getppid())
        return false;
#endif
    if (kill(pid, 0) == 0)
        return true;
    return false;
}
 
static void
do_status(void)
{
    pid_t       pid;
 
    pid = get_pgpid(true);
    /* Is there a pid file? */
    if (pid != 0)
    {
        /* standalone backend? */
        if (pid < 0)
        {
            pid = -pid;
            if (postmaster_is_alive(pid))
            {
                printf(_("%s: single-user server is running (PID: %d)\n"),
                       progname, (int) pid);
                return;
            }
        }
        else
            /* must be a postmaster */
        {
            if (postmaster_is_alive(pid))
            {
                char      **optlines;
                char      **curr_line;
                int         numlines;
 
                printf(_("%s: server is running (PID: %d)\n"),
                       progname, (int) pid);
 
                optlines = readfile(postopts_file, &numlines);
                if (optlines != NULL)
                {
                    for (curr_line = optlines; *curr_line != NULL; curr_line++)
                        puts(*curr_line);
 
                    /* Free the results of readfile */
                    free_readfile(optlines);
                }
                return;
            }
        }
    }
    printf(_("%s: no server running\n"), progname);
 
    /*
     * The Linux Standard Base Core Specification 3.1 says this should return
     * '3, program is not running'
     * https://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
     */
    exit(3);
}
 
 
 
static void
do_kill(pid_t pid)
{
    if (kill(pid, sig) != 0)
    {
        write_stderr(_("%s: could not send signal %d (PID: %d): %m\n"),
                     progname, sig, (int) pid);
        exit(1);
    }
}
 
#ifdef WIN32
 
static bool
pgwin32_IsInstalled(SC_HANDLE hSCM)
{
    SC_HANDLE   hService = OpenService(hSCM, register_servicename, SERVICE_QUERY_CONFIG);
    bool        bResult = (hService != NULL);
 
    if (bResult)
        CloseServiceHandle(hService);
    return bResult;
}
 
static char *
pgwin32_CommandLine(bool registration)
{
    PQExpBuffer cmdLine = createPQExpBuffer();
    char        cmdPath[MAXPGPATH];
    int         ret;
 
    if (registration)
    {
        ret = find_my_exec(argv0, cmdPath);
        if (ret != 0)
        {
            write_stderr(_("%s: could not find own program executable\n"), progname);
            exit(1);
        }
    }
    else
    {
        ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR,
                              cmdPath);
        if (ret != 0)
        {
            write_stderr(_("%s: could not find postgres program executable\n"), progname);
            exit(1);
        }
    }
 
    /* if path does not end in .exe, append it */
    if (strlen(cmdPath) < 4 ||
        pg_strcasecmp(cmdPath + strlen(cmdPath) - 4, ".exe") != 0)
        snprintf(cmdPath + strlen(cmdPath), sizeof(cmdPath) - strlen(cmdPath),
                 ".exe");
 
    /* use backslashes in path to avoid problems with some third-party tools */
    make_native_path(cmdPath);
 
    /* be sure to double-quote the executable's name in the command */
    appendPQExpBuffer(cmdLine, "\"%s\"", cmdPath);
 
    /* append assorted switches to the command line, as needed */
 
    if (registration)
        appendPQExpBuffer(cmdLine, " runservice -N \"%s\"",
                          register_servicename);
 
    if (pg_config)
    {
        /* We need the -D path to be absolute */
        char       *dataDir;
 
        if ((dataDir = make_absolute_path(pg_config)) == NULL)
        {
            /* make_absolute_path already reported the error */
            exit(1);
        }
        make_native_path(dataDir);
        appendPQExpBuffer(cmdLine, " -D \"%s\"", dataDir);
        free(dataDir);
    }
 
    if (registration && event_source != NULL)
        appendPQExpBuffer(cmdLine, " -e \"%s\"", event_source);
 
    if (registration && do_wait)
        appendPQExpBufferStr(cmdLine, " -w");
 
    /* Don't propagate a value from an environment variable. */
    if (registration && wait_seconds_arg && wait_seconds != DEFAULT_WAIT)
        appendPQExpBuffer(cmdLine, " -t %d", wait_seconds);
 
    if (registration && silent_mode)
        appendPQExpBufferStr(cmdLine, " -s");
 
    if (post_opts)
    {
        if (registration)
            appendPQExpBuffer(cmdLine, " -o \"%s\"", post_opts);
        else
            appendPQExpBuffer(cmdLine, " %s", post_opts);
    }
 
    return cmdLine->data;
}
 
static void
pgwin32_doRegister(void)
{
    SC_HANDLE   hService;
    SC_HANDLE   hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 
    if (hSCM == NULL)
    {
        write_stderr(_("%s: could not open service manager\n"), progname);
        exit(1);
    }
    if (pgwin32_IsInstalled(hSCM))
    {
        CloseServiceHandle(hSCM);
        write_stderr(_("%s: service \"%s\" already registered\n"), progname, register_servicename);
        exit(1);
    }
 
    if ((hService = CreateService(hSCM, register_servicename, register_servicename,
                                  SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
                                  pgctl_start_type, SERVICE_ERROR_NORMAL,
                                  pgwin32_CommandLine(true),
                                  NULL, NULL, "RPCSS\0", register_username, register_password)) == NULL)
    {
        CloseServiceHandle(hSCM);
        write_stderr(_("%s: could not register service \"%s\": error code %lu\n"),
                     progname, register_servicename,
                     GetLastError());
        exit(1);
    }
    CloseServiceHandle(hService);
    CloseServiceHandle(hSCM);
}
 
static void
pgwin32_doUnregister(void)
{
    SC_HANDLE   hService;
    SC_HANDLE   hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 
    if (hSCM == NULL)
    {
        write_stderr(_("%s: could not open service manager\n"), progname);
        exit(1);
    }
    if (!pgwin32_IsInstalled(hSCM))
    {
        CloseServiceHandle(hSCM);
        write_stderr(_("%s: service \"%s\" not registered\n"), progname, register_servicename);
        exit(1);
    }
 
    if ((hService = OpenService(hSCM, register_servicename, DELETE)) == NULL)
    {
        CloseServiceHandle(hSCM);
        write_stderr(_("%s: could not open service \"%s\": error code %lu\n"),
                     progname, register_servicename,
                     GetLastError());
        exit(1);
    }
    if (!DeleteService(hService))
    {
        CloseServiceHandle(hService);
        CloseServiceHandle(hSCM);
        write_stderr(_("%s: could not unregister service \"%s\": error code %lu\n"),
                     progname, register_servicename,
                     GetLastError());
        exit(1);
    }
    CloseServiceHandle(hService);
    CloseServiceHandle(hSCM);
}
 
static void
pgwin32_SetServiceStatus(DWORD currentState)
{
    status.dwCurrentState = currentState;
    SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
}
 
static void WINAPI
pgwin32_ServiceHandler(DWORD request)
{
    switch (request)
    {
        case SERVICE_CONTROL_STOP:
        case SERVICE_CONTROL_SHUTDOWN:
 
            /*
             * We only need a short wait hint here as it just needs to wait
             * for the next checkpoint. They occur every 5 seconds during
             * shutdown
             */
            status.dwWaitHint = 10000;
            pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
            SetEvent(shutdownEvent);
            return;
 
        case SERVICE_CONTROL_PAUSE:
            /* Win32 config reloading */
            status.dwWaitHint = 5000;
            kill(postmasterPID, SIGHUP);
            return;
 
            /* FIXME: These could be used to replace other signals etc */
        case SERVICE_CONTROL_CONTINUE:
        case SERVICE_CONTROL_INTERROGATE:
        default:
            break;
    }
}
 
static void WINAPI
pgwin32_ServiceMain(DWORD argc, LPTSTR *argv)
{
    PROCESS_INFORMATION pi;
    DWORD       ret;
 
    /* Initialize variables */
    status.dwWin32ExitCode = S_OK;
    status.dwCheckPoint = 0;
    status.dwWaitHint = 60000;
    status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE;
    status.dwServiceSpecificExitCode = 0;
    status.dwCurrentState = SERVICE_START_PENDING;
 
    memset(&pi, 0, sizeof(pi));
 
    read_post_opts();
 
    /* Register the control request handler */
    if ((hStatus = RegisterServiceCtrlHandler(register_servicename, pgwin32_ServiceHandler)) == (SERVICE_STATUS_HANDLE) 0)
        return;
 
    if ((shutdownEvent = CreateEvent(NULL, true, false, NULL)) == NULL)
        return;
 
    /* Start the postmaster */
    pgwin32_SetServiceStatus(SERVICE_START_PENDING);
    if (!CreateRestrictedProcess(pgwin32_CommandLine(false), &pi, true))
    {
        pgwin32_SetServiceStatus(SERVICE_STOPPED);
        return;
    }
    postmasterPID = pi.dwProcessId;
    postmasterProcess = pi.hProcess;
    CloseHandle(pi.hThread);
 
    if (do_wait)
    {
        write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Waiting for server startup...\n"));
        if (wait_for_postmaster_start(postmasterPID, true) != POSTMASTER_READY)
        {
            write_eventlog(EVENTLOG_ERROR_TYPE, _("Timed out waiting for server startup\n"));
            pgwin32_SetServiceStatus(SERVICE_STOPPED);
            return;
        }
        write_eventlog(EVENTLOG_INFORMATION_TYPE, _("Server started and accepting connections\n"));
    }
 
    pgwin32_SetServiceStatus(SERVICE_RUNNING);
 
    /* Wait for quit... */
    ret = WaitForMultipleObjects(2, shutdownHandles, FALSE, INFINITE);
 
    pgwin32_SetServiceStatus(SERVICE_STOP_PENDING);
    switch (ret)
    {
        case WAIT_OBJECT_0:     /* shutdown event */
            {
                /*
                 * status.dwCheckPoint can be incremented by
                 * wait_for_postmaster_start(), so it might not start from 0.
                 */
                int         maxShutdownCheckPoint = status.dwCheckPoint + 12;
 
                kill(postmasterPID, SIGINT);
 
                /*
                 * Increment the checkpoint and try again. Abort after 12
                 * checkpoints as the postmaster has probably hung.
                 */
                while (WaitForSingleObject(postmasterProcess, 5000) == WAIT_TIMEOUT && status.dwCheckPoint < maxShutdownCheckPoint)
                {
                    status.dwCheckPoint++;
                    SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
                }
                break;
            }
 
        case (WAIT_OBJECT_0 + 1):   /* postmaster went down */
            break;
 
        default:
            /* shouldn't get here? */
            break;
    }
 
    CloseHandle(shutdownEvent);
    CloseHandle(postmasterProcess);
 
    pgwin32_SetServiceStatus(SERVICE_STOPPED);
}
 
static void
pgwin32_doRunAsService(void)
{
    SERVICE_TABLE_ENTRY st[] = {{register_servicename, pgwin32_ServiceMain},
    {NULL, NULL}};
 
    if (StartServiceCtrlDispatcher(st) == 0)
    {
        write_stderr(_("%s: could not start service \"%s\": error code %lu\n"),
                     progname, register_servicename,
                     GetLastError());
        exit(1);
    }
}
 
 
/*
 * Set up STARTUPINFO for the new process to inherit this process' handles.
 *
 * Process started as services appear to have "empty" handles (GetStdHandle()
 * returns NULL) rather than invalid ones. But passing down NULL ourselves
 * doesn't work, it's interpreted as STARTUPINFO->hStd* not being set. But we
 * can pass down INVALID_HANDLE_VALUE - which makes GetStdHandle() in the new
 * process (and its child processes!) return INVALID_HANDLE_VALUE. Which
 * achieves the goal of postmaster running in a similar environment as pg_ctl.
 */
static void
InheritStdHandles(STARTUPINFO *si)
{
    si->dwFlags |= STARTF_USESTDHANDLES;
    si->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    if (si->hStdInput == NULL)
        si->hStdInput = INVALID_HANDLE_VALUE;
    si->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    if (si->hStdOutput == NULL)
        si->hStdOutput = INVALID_HANDLE_VALUE;
    si->hStdError = GetStdHandle(STD_ERROR_HANDLE);
    if (si->hStdError == NULL)
        si->hStdError = INVALID_HANDLE_VALUE;
}
 
/*
 * Create a restricted token, a job object sandbox, and execute the specified
 * process with it.
 *
 * Returns 0 on success, non-zero on failure, same as CreateProcess().
 *
 * NOTE! Job object will only work when running as a service, because it's
 * automatically destroyed when pg_ctl exits.
 */
static int
CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service)
{
    int         r;
    BOOL        b;
    STARTUPINFO si;
    HANDLE      origToken;
    HANDLE      restrictedToken;
    BOOL        inJob;
    SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
    SID_AND_ATTRIBUTES dropSids[2];
    PTOKEN_PRIVILEGES delPrivs;
 
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
 
    /*
     * Set stdin/stdout/stderr handles to be inherited in the child process.
     * That allows postmaster and the processes it starts to perform
     * additional checks to see if running in a service (otherwise they get
     * the default console handles - which point to "somewhere").
     */
    InheritStdHandles(&si);
 
    /* Open the current token to use as a base for the restricted one */
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &origToken))
    {
        /*
         * Most Windows targets make DWORD a 32-bit unsigned long, but in case
         * it doesn't cast DWORD before printing.
         */
        write_stderr(_("%s: could not open process token: error code %lu\n"),
                     progname, GetLastError());
        return 0;
    }
 
    /* Allocate list of SIDs to remove */
    ZeroMemory(&dropSids, sizeof(dropSids));
    if (!AllocateAndInitializeSid(&NtAuthority, 2,
                                  SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0,
                                  0, &dropSids[0].Sid) ||
        !AllocateAndInitializeSid(&NtAuthority, 2,
                                  SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_POWER_USERS, 0, 0, 0, 0, 0,
                                  0, &dropSids[1].Sid))
    {
        write_stderr(_("%s: could not allocate SIDs: error code %lu\n"),
                     progname, GetLastError());
        return 0;
    }
 
    /* Get list of privileges to remove */
    delPrivs = GetPrivilegesToDelete(origToken);
    if (delPrivs == NULL)
        /* Error message already printed */
        return 0;
 
    b = CreateRestrictedToken(origToken,
                              0,
                              sizeof(dropSids) / sizeof(dropSids[0]),
                              dropSids,
                              delPrivs->PrivilegeCount, delPrivs->Privileges,
                              0, NULL,
                              &restrictedToken);
 
    free(delPrivs);
    FreeSid(dropSids[1].Sid);
    FreeSid(dropSids[0].Sid);
    CloseHandle(origToken);
 
    if (!b)
    {
        write_stderr(_("%s: could not create restricted token: error code %lu\n"),
                     progname, GetLastError());
        return 0;
    }
 
    AddUserToTokenDacl(restrictedToken);
    r = CreateProcessAsUser(restrictedToken, NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, processInfo);
 
    if (IsProcessInJob(processInfo->hProcess, NULL, &inJob))
    {
        if (!inJob)
        {
            /*
             * Job objects are working, and the new process isn't in one, so
             * we can create one safely. If any problems show up when setting
             * it, we're going to ignore them.
             */
            HANDLE      job;
            char        jobname[128];
 
            sprintf(jobname, "PostgreSQL_%lu", processInfo->dwProcessId);
 
            job = CreateJobObject(NULL, jobname);
            if (job)
            {
                JOBOBJECT_BASIC_LIMIT_INFORMATION basicLimit;
                JOBOBJECT_BASIC_UI_RESTRICTIONS uiRestrictions;
                JOBOBJECT_SECURITY_LIMIT_INFORMATION securityLimit;
 
                ZeroMemory(&basicLimit, sizeof(basicLimit));
                ZeroMemory(&uiRestrictions, sizeof(uiRestrictions));
                ZeroMemory(&securityLimit, sizeof(securityLimit));
 
                basicLimit.LimitFlags = JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION | JOB_OBJECT_LIMIT_PRIORITY_CLASS;
                basicLimit.PriorityClass = NORMAL_PRIORITY_CLASS;
                SetInformationJobObject(job, JobObjectBasicLimitInformation, &basicLimit, sizeof(basicLimit));
 
                uiRestrictions.UIRestrictionsClass = JOB_OBJECT_UILIMIT_DESKTOP | JOB_OBJECT_UILIMIT_DISPLAYSETTINGS |
                    JOB_OBJECT_UILIMIT_EXITWINDOWS | JOB_OBJECT_UILIMIT_READCLIPBOARD |
                    JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS | JOB_OBJECT_UILIMIT_WRITECLIPBOARD;
 
                SetInformationJobObject(job, JobObjectBasicUIRestrictions, &uiRestrictions, sizeof(uiRestrictions));
 
                securityLimit.SecurityLimitFlags = JOB_OBJECT_SECURITY_NO_ADMIN | JOB_OBJECT_SECURITY_ONLY_TOKEN;
                securityLimit.JobToken = restrictedToken;
                SetInformationJobObject(job, JobObjectSecurityLimitInformation, &securityLimit, sizeof(securityLimit));
 
                AssignProcessToJobObject(job, processInfo->hProcess);
            }
        }
    }
 
    CloseHandle(restrictedToken);
 
    ResumeThread(processInfo->hThread);
 
    /*
     * We intentionally don't close the job object handle, because we want the
     * object to live on until pg_ctl shuts down.
     */
    return r;
}
 
/*
 * Get a list of privileges to delete from the access token. We delete all privileges
 * except SeLockMemoryPrivilege which is needed to use large pages, and
 * SeChangeNotifyPrivilege which is enabled by default in DISABLE_MAX_PRIVILEGE.
 */
static PTOKEN_PRIVILEGES
GetPrivilegesToDelete(HANDLE hToken)
{
    int         i,
                j;
    DWORD       length;
    PTOKEN_PRIVILEGES tokenPrivs;
    LUID        luidLockPages;
    LUID        luidChangeNotify;
 
    if (!LookupPrivilegeValue(NULL, SE_LOCK_MEMORY_NAME, &luidLockPages) ||
        !LookupPrivilegeValue(NULL, SE_CHANGE_NOTIFY_NAME, &luidChangeNotify))
    {
        write_stderr(_("%s: could not get LUIDs for privileges: error code %lu\n"),
                     progname, GetLastError());
        return NULL;
    }
 
    if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &length) &&
        GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    {
        write_stderr(_("%s: could not get token information: error code %lu\n"),
                     progname, GetLastError());
        return NULL;
    }
 
    tokenPrivs = (PTOKEN_PRIVILEGES) pg_malloc_extended(length,
                                                        MCXT_ALLOC_NO_OOM);
    if (tokenPrivs == NULL)
    {
        write_stderr(_("%s: out of memory\n"), progname);
        return NULL;
    }
 
    if (!GetTokenInformation(hToken, TokenPrivileges, tokenPrivs, length, &length))
    {
        write_stderr(_("%s: could not get token information: error code %lu\n"),
                     progname, GetLastError());
        free(tokenPrivs);
        return NULL;
    }
 
    for (i = 0; i < tokenPrivs->PrivilegeCount; i++)
    {
        if (memcmp(&tokenPrivs->Privileges[i].Luid, &luidLockPages, sizeof(LUID)) == 0 ||
            memcmp(&tokenPrivs->Privileges[i].Luid, &luidChangeNotify, sizeof(LUID)) == 0)
        {
            for (j = i; j < tokenPrivs->PrivilegeCount - 1; j++)
                tokenPrivs->Privileges[j] = tokenPrivs->Privileges[j + 1];
            tokenPrivs->PrivilegeCount--;
        }
    }
 
    return tokenPrivs;
}
#endif                          /* WIN32 */
 
static void
do_advice(void)
{
    write_stderr(_("Try \"%s --help\" for more information.\n"), progname);
}
 
 
 
static void
do_help(void)
{
    printf(_("%s is a utility to initialize, start, stop, or control a PostgreSQL server.\n\n"), progname);
    printf(_("Usage:\n"));
    printf(_("  %s init[db]   [-D DATADIR] [-s] [-o OPTIONS]\n"), progname);
    printf(_("  %s start      [-D DATADIR] [-l FILENAME] [-W] [-t SECS] [-s]\n"
             "                    [-o OPTIONS] [-p PATH] [-c]\n"), progname);
    printf(_("  %s stop       [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"), progname);
    printf(_("  %s restart    [-D DATADIR] [-m SHUTDOWN-MODE] [-W] [-t SECS] [-s]\n"
             "                    [-o OPTIONS] [-c]\n"), progname);
    printf(_("  %s reload     [-D DATADIR] [-s]\n"), progname);
    printf(_("  %s status     [-D DATADIR]\n"), progname);
    printf(_("  %s promote    [-D DATADIR] [-W] [-t SECS] [-s]\n"), progname);
    printf(_("  %s logrotate  [-D DATADIR] [-s]\n"), progname);
    printf(_("  %s kill       SIGNALNAME PID\n"), progname);
#ifdef WIN32
    printf(_("  %s register   [-D DATADIR] [-N SERVICENAME] [-U USERNAME] [-P PASSWORD]\n"
             "                    [-S START-TYPE] [-e SOURCE] [-W] [-t SECS] [-s] [-o OPTIONS]\n"), progname);
    printf(_("  %s unregister [-N SERVICENAME]\n"), progname);
#endif
 
    printf(_("\nCommon options:\n"));
    printf(_("  -D, --pgdata=DATADIR   location of the database storage area\n"));
#ifdef WIN32
    printf(_("  -e SOURCE              event source for logging when running as a service\n"));
#endif
    printf(_("  -s, --silent           only print errors, no informational messages\n"));
    printf(_("  -t, --timeout=SECS     seconds to wait when using -w option\n"));
    printf(_("  -V, --version          output version information, then exit\n"));
    printf(_("  -w, --wait             wait until operation completes (default)\n"));
    printf(_("  -W, --no-wait          do not wait until operation completes\n"));
    printf(_("  -?, --help             show this help, then exit\n"));
    printf(_("If the -D option is omitted, the environment variable PGDATA is used.\n"));
 
    printf(_("\nOptions for start or restart:\n"));
#if defined(HAVE_GETRLIMIT)
    printf(_("  -c, --core-files       allow postgres to produce core files\n"));
#else
    printf(_("  -c, --core-files       not applicable on this platform\n"));
#endif
    printf(_("  -l, --log=FILENAME     write (or append) server log to FILENAME\n"));
    printf(_("  -o, --options=OPTIONS  command line options to pass to postgres\n"
             "                         (PostgreSQL server executable) or initdb\n"));
    printf(_("  -p PATH-TO-POSTGRES    normally not necessary\n"));
    printf(_("\nOptions for stop or restart:\n"));
    printf(_("  -m, --mode=MODE        MODE can be \"smart\", \"fast\", or \"immediate\"\n"));
 
    printf(_("\nShutdown modes are:\n"));
    printf(_("  smart       quit after all clients have disconnected\n"));
    printf(_("  fast        quit directly, with proper shutdown (default)\n"));
    printf(_("  immediate   quit without complete shutdown; will lead to recovery on restart\n"));
 
    printf(_("\nAllowed signal names for kill:\n"));
    printf("  ABRT HUP INT KILL QUIT TERM USR1 USR2\n");
 
#ifdef WIN32
    printf(_("\nOptions for register and unregister:\n"));
    printf(_("  -N SERVICENAME  service name with which to register PostgreSQL server\n"));
    printf(_("  -P PASSWORD     password of account to register PostgreSQL server\n"));
    printf(_("  -U USERNAME     user name of account to register PostgreSQL server\n"));
    printf(_("  -S START-TYPE   service start type to register PostgreSQL server\n"));
 
    printf(_("\nStart types are:\n"));
    printf(_("  auto       start service automatically during system startup (default)\n"));
    printf(_("  demand     start service on demand\n"));
#endif
 
    printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
    printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
}
 
 
 
static void
set_mode(char *modeopt)
{
    if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
    {
        shutdown_mode = SMART_MODE;
        sig = SIGTERM;
    }
    else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
    {
        shutdown_mode = FAST_MODE;
        sig = SIGINT;
    }
    else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
    {
        shutdown_mode = IMMEDIATE_MODE;
        sig = SIGQUIT;
    }
    else
    {
        write_stderr(_("%s: unrecognized shutdown mode \"%s\"\n"), progname, modeopt);
        do_advice();
        exit(1);
    }
}
 
 
 
static void
set_sig(char *signame)
{
    if (strcmp(signame, "HUP") == 0)
        sig = SIGHUP;
    else if (strcmp(signame, "INT") == 0)
        sig = SIGINT;
    else if (strcmp(signame, "QUIT") == 0)
        sig = SIGQUIT;
    else if (strcmp(signame, "ABRT") == 0)
        sig = SIGABRT;
    else if (strcmp(signame, "KILL") == 0)
        sig = SIGKILL;
    else if (strcmp(signame, "TERM") == 0)
        sig = SIGTERM;
    else if (strcmp(signame, "USR1") == 0)
        sig = SIGUSR1;
    else if (strcmp(signame, "USR2") == 0)
        sig = SIGUSR2;
    else
    {
        write_stderr(_("%s: unrecognized signal name \"%s\"\n"), progname, signame);
        do_advice();
        exit(1);
    }
}
 
 
#ifdef WIN32
static void
set_starttype(char *starttypeopt)
{
    if (strcmp(starttypeopt, "a") == 0 || strcmp(starttypeopt, "auto") == 0)
        pgctl_start_type = SERVICE_AUTO_START;
    else if (strcmp(starttypeopt, "d") == 0 || strcmp(starttypeopt, "demand") == 0)
        pgctl_start_type = SERVICE_DEMAND_START;
    else
    {
        write_stderr(_("%s: unrecognized start type \"%s\"\n"), progname, starttypeopt);
        do_advice();
        exit(1);
    }
}
#endif
 
/*
 * adjust_data_dir
 *
 * If a configuration-only directory was specified, find the real data dir.
 */
static void
adjust_data_dir(void)
{
    char        filename[MAXPGPATH];
    char       *my_exec_path,
               *cmd;
    FILE       *fd;
 
    /* do nothing if we're working without knowledge of data dir */
    if (pg_config == NULL)
        return;
 
    /* If there is no postgresql.conf, it can't be a config-only dir */
    snprintf(filename, sizeof(filename), "%s/postgresql.conf", pg_config);
    if ((fd = fopen(filename, "r")) == NULL)
        return;
    fclose(fd);
 
    /* If PG_VERSION exists, it can't be a config-only dir */
    snprintf(filename, sizeof(filename), "%s/PG_VERSION", pg_config);
    if ((fd = fopen(filename, "r")) != NULL)
    {
        fclose(fd);
        return;
    }
 
    /* Must be a configuration directory, so find the data directory */
 
    /* we use a private my_exec_path to avoid interfering with later uses */
    if (exec_path == NULL)
        my_exec_path = find_other_exec_or_die(argv0, "postgres", PG_BACKEND_VERSIONSTR);
    else
        my_exec_path = pg_strdup(exec_path);
 
    /* it's important for -C to be the first option, see main.c */
    cmd = psprintf("\"%s\" -C data_directory %s%s",
                   my_exec_path,
                   pgdata_opt ? pgdata_opt : "",
                   post_opts ? post_opts : "");
    fflush(NULL);
 
    fd = popen(cmd, "r");
    if (fd == NULL || fgets(filename, sizeof(filename), fd) == NULL || pclose(fd) != 0)
    {
        write_stderr(_("%s: could not determine the data directory using command \"%s\"\n"), progname, cmd);
        exit(1);
    }
    free(my_exec_path);
 
    /* strip trailing newline and carriage return */
    (void) pg_strip_crlf(filename);
 
    free(pg_data);
    pg_data = pg_strdup(filename);
    canonicalize_path(pg_data);
}
 
 
static DBState
get_control_dbstate(void)
{
    DBState     ret;
    bool        crc_ok;
    ControlFileData *control_file_data = get_controlfile(pg_data, &crc_ok);
 
    if (!crc_ok)
    {
        write_stderr(_("%s: control file appears to be corrupt\n"), progname);
        exit(1);
    }
 
    ret = control_file_data->state;
    pfree(control_file_data);
    return ret;
}
 
 
int
main(int argc, char **argv)
{
    static struct option long_options[] = {
        {"help", no_argument, NULL, '?'},
        {"version", no_argument, NULL, 'V'},
        {"log", required_argument, NULL, 'l'},
        {"mode", required_argument, NULL, 'm'},
        {"pgdata", required_argument, NULL, 'D'},
        {"options", required_argument, NULL, 'o'},
        {"silent", no_argument, NULL, 's'},
        {"timeout", required_argument, NULL, 't'},
        {"core-files", no_argument, NULL, 'c'},
        {"wait", no_argument, NULL, 'w'},
        {"no-wait", no_argument, NULL, 'W'},
        {NULL, 0, NULL, 0}
    };
 
    char       *env_wait;
    int         option_index;
    int         c;
    pid_t       killproc = 0;
 
    pg_logging_init(argv[0]);
    progname = get_progname(argv[0]);
    set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_ctl"));
    start_time = time(NULL);
 
    /*
     * save argv[0] so do_start() can look for the postmaster if necessary. we
     * don't look for postmaster here because in many cases we won't need it.
     */
    argv0 = argv[0];
 
    /* Set restrictive mode mask until PGDATA permissions are checked */
    umask(PG_MODE_MASK_OWNER);
 
    /* support --help and --version even if invoked as root */
    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
        {
            do_help();
            exit(0);
        }
        else if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("pg_ctl (PostgreSQL) " PG_VERSION);
            exit(0);
        }
    }
 
    /*
     * Disallow running as root, to forestall any possible security holes.
     */
#ifndef WIN32
    if (geteuid() == 0)
    {
        write_stderr(_("%s: cannot be run as root\n"
                       "Please log in (using, e.g., \"su\") as the "
                       "(unprivileged) user that will\n"
                       "own the server process.\n"),
                     progname);
        exit(1);
    }
#endif
 
    env_wait = getenv("PGCTLTIMEOUT");
    if (env_wait != NULL)
        wait_seconds = atoi(env_wait);
 
    /* process command-line options */
    while ((c = getopt_long(argc, argv, "cD:e:l:m:N:o:p:P:sS:t:U:wW",
                            long_options, &option_index)) != -1)
    {
        switch (c)
        {
            case 'D':
                {
                    char       *pgdata_D;
 
                    pgdata_D = pg_strdup(optarg);
                    canonicalize_path(pgdata_D);
                    setenv("PGDATA", pgdata_D, 1);
 
                    /*
                     * We could pass PGDATA just in an environment variable
                     * but we do -D too for clearer postmaster 'ps' display
                     */
                    pgdata_opt = psprintf("-D \"%s\" ", pgdata_D);
                    free(pgdata_D);
                    break;
                }
            case 'e':
                event_source = pg_strdup(optarg);
                break;
            case 'l':
                log_file = pg_strdup(optarg);
                break;
            case 'm':
                set_mode(optarg);
                break;
            case 'N':
                register_servicename = pg_strdup(optarg);
                break;
            case 'o':
                /* append option? */
                if (!post_opts)
                    post_opts = pg_strdup(optarg);
                else
                {
                    char       *old_post_opts = post_opts;
 
                    post_opts = psprintf("%s %s", old_post_opts, optarg);
                    free(old_post_opts);
                }
                break;
            case 'p':
                exec_path = pg_strdup(optarg);
                break;
            case 'P':
                register_password = pg_strdup(optarg);
                break;
            case 's':
                silent_mode = true;
                break;
            case 'S':
#ifdef WIN32
                set_starttype(optarg);
#else
                write_stderr(_("%s: -S option not supported on this platform\n"),
                             progname);
                exit(1);
#endif
                break;
            case 't':
                wait_seconds = atoi(optarg);
                wait_seconds_arg = true;
                break;
            case 'U':
                if (strchr(optarg, '\\'))
                    register_username = pg_strdup(optarg);
                else
                    /* Prepend .\ for local accounts */
                    register_username = psprintf(".\\%s", optarg);
                break;
            case 'w':
                do_wait = true;
                break;
            case 'W':
                do_wait = false;
                break;
            case 'c':
                allow_core_files = true;
                break;
            default:
                /* getopt_long already issued a suitable error message */
                do_advice();
                exit(1);
        }
    }
 
    /* Process an action */
    if (optind < argc)
    {
        if (strcmp(argv[optind], "init") == 0
            || strcmp(argv[optind], "initdb") == 0)
            ctl_command = INIT_COMMAND;
        else if (strcmp(argv[optind], "start") == 0)
            ctl_command = START_COMMAND;
        else if (strcmp(argv[optind], "stop") == 0)
            ctl_command = STOP_COMMAND;
        else if (strcmp(argv[optind], "restart") == 0)
            ctl_command = RESTART_COMMAND;
        else if (strcmp(argv[optind], "reload") == 0)
            ctl_command = RELOAD_COMMAND;
        else if (strcmp(argv[optind], "status") == 0)
            ctl_command = STATUS_COMMAND;
        else if (strcmp(argv[optind], "promote") == 0)
            ctl_command = PROMOTE_COMMAND;
        else if (strcmp(argv[optind], "logrotate") == 0)
            ctl_command = LOGROTATE_COMMAND;
        else if (strcmp(argv[optind], "kill") == 0)
        {
            if (argc - optind < 3)
            {
                write_stderr(_("%s: missing arguments for kill mode\n"), progname);
                do_advice();
                exit(1);
            }
            ctl_command = KILL_COMMAND;
            set_sig(argv[++optind]);
            killproc = atol(argv[++optind]);
        }
#ifdef WIN32
        else if (strcmp(argv[optind], "register") == 0)
            ctl_command = REGISTER_COMMAND;
        else if (strcmp(argv[optind], "unregister") == 0)
            ctl_command = UNREGISTER_COMMAND;
        else if (strcmp(argv[optind], "runservice") == 0)
            ctl_command = RUN_AS_SERVICE_COMMAND;
#endif
        else
        {
            write_stderr(_("%s: unrecognized operation mode \"%s\"\n"), progname, argv[optind]);
            do_advice();
            exit(1);
        }
        optind++;
    }
 
    if (optind < argc)
    {
        write_stderr(_("%s: too many command-line arguments (first is \"%s\")\n"), progname, argv[optind]);
        do_advice();
        exit(1);
    }
 
    if (ctl_command == NO_COMMAND)
    {
        write_stderr(_("%s: no operation specified\n"), progname);
        do_advice();
        exit(1);
    }
 
    /* Note we put any -D switch into the env var above */
    pg_config = getenv("PGDATA");
    if (pg_config)
    {
        pg_config = pg_strdup(pg_config);
        canonicalize_path(pg_config);
        pg_data = pg_strdup(pg_config);
    }
 
    /* -D might point at config-only directory; if so find the real PGDATA */
    adjust_data_dir();
 
    /* Complain if -D needed and not provided */
    if (pg_config == NULL &&
        ctl_command != KILL_COMMAND && ctl_command != UNREGISTER_COMMAND)
    {
        write_stderr(_("%s: no database directory specified and environment variable PGDATA unset\n"),
                     progname);
        do_advice();
        exit(1);
    }
 
    if (ctl_command == RELOAD_COMMAND)
    {
        sig = SIGHUP;
        do_wait = false;
    }
 
    if (pg_data)
    {
        snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
        snprintf(version_file, MAXPGPATH, "%s/PG_VERSION", pg_data);
        snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
 
        /*
         * Set mask based on PGDATA permissions,
         *
         * Don't error here if the data directory cannot be stat'd. This is
         * handled differently based on the command and we don't want to
         * interfere with that logic.
         */
        if (GetDataDirectoryCreatePerm(pg_data))
            umask(pg_mode_mask);
    }
 
    switch (ctl_command)
    {
        case INIT_COMMAND:
            do_init();
            break;
        case STATUS_COMMAND:
            do_status();
            break;
        case START_COMMAND:
            do_start();
            break;
        case STOP_COMMAND:
            do_stop();
            break;
        case RESTART_COMMAND:
            do_restart();
            break;
        case RELOAD_COMMAND:
            do_reload();
            break;
        case PROMOTE_COMMAND:
            do_promote();
            break;
        case LOGROTATE_COMMAND:
            do_logrotate();
            break;
        case KILL_COMMAND:
            do_kill(killproc);
            break;
#ifdef WIN32
        case REGISTER_COMMAND:
            pgwin32_doRegister();
            break;
        case UNREGISTER_COMMAND:
            pgwin32_doUnregister();
            break;
        case RUN_AS_SERVICE_COMMAND:
            pgwin32_doRunAsService();
            break;
#endif
        default:
            break;
    }
 
    exit(0);
}