exec.c File Reference

#include "postgres.h"
#include <signal.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>

Include dependency graph for exec.c:

Go to the source code of this file.

Macros
#define	log_error(errcodefn, ...)    ereport(LOG, (errcodefn, errmsg_internal(__VA_ARGS__)))

Functions
static int	resolve_symlinks (char *path)
int	validate_exec (const char *path)
int	find_my_exec (const char *argv0, char *retpath)
int	find_other_exec (const char *argv0, const char *target, const char *versionstr, char *retpath)
char *	pipe_read_line (char *cmd, char *line, int maxsize)
int	pclose_check (FILE *stream)
void	set_pglocale_pgservice (const char *argv0, const char *app)

Macro Definition Documentation

log_error

#define log_error	(		errcodefn,
			...
	)		ereport(LOG, (errcodefn, errmsg_internal(__VA_ARGS__)))

Definition at line 54 of file exec.c.

Function Documentation

find_my_exec()

int find_my_exec	(	const char *	argv0,
		char *	retpath
	)

Definition at line 152 of file exec.c.

{
    char        cwd[MAXPGPATH],
                test_path[MAXPGPATH];
    char       *path;
 
    if (!getcwd(cwd, MAXPGPATH))
    {
        log_error(errcode_for_file_access(),
                  _("could not identify current directory: %m"));
        return -1;
    }
 
    /*
     * If argv0 contains a separator, then PATH wasn't used.
     */
    if (first_dir_separator(argv0) != NULL)
    {
        if (is_absolute_path(argv0))
            strlcpy(retpath, argv0, MAXPGPATH);
        else
            join_path_components(retpath, cwd, argv0);
        canonicalize_path(retpath);
 
        if (validate_exec(retpath) == 0)
            return resolve_symlinks(retpath);
 
        log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  _("invalid binary \"%s\": %m"), retpath);
        return -1;
    }
 
#ifdef WIN32
    /* Win32 checks the current directory first for names without slashes */
    join_path_components(retpath, cwd, argv0);
    if (validate_exec(retpath) == 0)
        return resolve_symlinks(retpath);
#endif
 
    /*
     * Since no explicit path was supplied, the user must have been relying on
     * PATH.  We'll search the same PATH.
     */
    if ((path = getenv("PATH")) && *path)
    {
        char       *startp = NULL,
                   *endp = NULL;
 
        do
        {
            if (!startp)
                startp = path;
            else
                startp = endp + 1;
 
            endp = first_path_var_separator(startp);
            if (!endp)
                endp = startp + strlen(startp); /* point to end */
 
            strlcpy(test_path, startp, Min(endp - startp + 1, MAXPGPATH));
 
            if (is_absolute_path(test_path))
                join_path_components(retpath, test_path, argv0);
            else
            {
                join_path_components(retpath, cwd, test_path);
                join_path_components(retpath, retpath, argv0);
            }
            canonicalize_path(retpath);
 
            switch (validate_exec(retpath))
            {
                case 0:         /* found ok */
                    return resolve_symlinks(retpath);
                case -1:        /* wasn't even a candidate, keep looking */
                    break;
                case -2:        /* found but disqualified */
                    log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),
                              _("could not read binary \"%s\": %m"),
                              retpath);
                    break;
            }
        } while (*endp);
    }
 
    log_error(errcode(ERRCODE_UNDEFINED_FILE),
              _("could not find a \"%s\" to execute"), argv0);
    return -1;
}

References _, argv0, canonicalize_path(), errcode(), errcode_for_file_access(), first_dir_separator(), first_path_var_separator(), is_absolute_path, join_path_components(), log_error, MAXPGPATH, Min, resolve_symlinks(), strlcpy(), and validate_exec().

Referenced by ensureCleanShutdown(), find_other_exec(), find_other_exec_or_die(), getInstallationPaths(), getRestoreCommand(), InitStandaloneProcess(), main(), process_psqlrc(), set_pglocale_pgservice(), setup(), and setup_bin_paths().

find_other_exec()

int find_other_exec	(	const char *	argv0,
		const char *	target,
		const char *	versionstr,
		char *	retpath
	)

Definition at line 351 of file exec.c.

{
    char        cmd[MAXPGPATH];
    char        line[MAXPGPATH];
 
    if (find_my_exec(argv0, retpath) < 0)
        return -1;
 
    /* Trim off program name and keep just directory */
    *last_dir_separator(retpath) = '\0';
    canonicalize_path(retpath);
 
    /* Now append the other program's name */
    snprintf(retpath + strlen(retpath), MAXPGPATH - strlen(retpath),
             "/%s%s", target, EXE);
 
    if (validate_exec(retpath) != 0)
        return -1;
 
    snprintf(cmd, sizeof(cmd), "\"%s\" -V", retpath);
 
    if (!pipe_read_line(cmd, line, sizeof(line)))
        return -1;
 
    if (strcmp(line, versionstr) != 0)
        return -2;
 
    return 0;
}

References argv0, canonicalize_path(), EXE, find_my_exec(), last_dir_separator(), MAXPGPATH, pipe_read_line(), snprintf, and validate_exec().

Referenced by ensureCleanShutdown(), find_other_exec_or_die(), getInstallationPaths(), getRestoreCommand(), isolation_start_test(), main(), and setup_bin_paths().

pclose_check()

int pclose_check

(

FILE *

stream

)

Definition at line 422 of file exec.c.

{
    int         exitstatus;
    char       *reason;
 
    exitstatus = pclose(stream);
 
    if (exitstatus == 0)
        return 0;               /* all is well */
 
    if (exitstatus == -1)
    {
        /* pclose() itself failed, and hopefully set errno */
        log_error(errcode(ERRCODE_SYSTEM_ERROR),
                  _("%s() failed: %m"), "pclose");
    }
    else
    {
        reason = wait_result_to_str(exitstatus);
        log_error(errcode(ERRCODE_SYSTEM_ERROR),
                  "%s", reason);
        pfree(reason);
    }
    return exitstatus;
}

References _, errcode(), log_error, pfree(), and wait_result_to_str().

Referenced by pipe_read_line().

pipe_read_line()

char* pipe_read_line	(	char *	cmd,
		char *	line,
		int	maxsize
	)

Definition at line 387 of file exec.c.

{
    FILE       *pgver;
 
    fflush(NULL);
 
    errno = 0;
    if ((pgver = popen(cmd, "r")) == NULL)
    {
        perror("popen failure");
        return NULL;
    }
 
    errno = 0;
    if (fgets(line, maxsize, pgver) == NULL)
    {
        if (feof(pgver))
            fprintf(stderr, "no data was returned by command \"%s\"\n", cmd);
        else
            perror("fgets failure");
        pclose(pgver);          /* no error checking */
        return NULL;
    }
 
    if (pclose_check(pgver))
        return NULL;
 
    return line;
}

References fflush(), fprintf, and pclose_check().

Referenced by check_exec(), find_other_exec(), and getRestoreCommand().

resolve_symlinks()

static int resolve_symlinks ( char *  path )

static

Definition at line 259 of file exec.c.

{
#ifdef HAVE_READLINK
    struct stat buf;
    char        orig_wd[MAXPGPATH],
                link_buf[MAXPGPATH];
    char       *fname;
 
    /*
     * To resolve a symlink properly, we have to chdir into its directory and
     * then chdir to where the symlink points; otherwise we may fail to
     * resolve relative links correctly (consider cases involving mount
     * points, for example).  After following the final symlink, we use
     * getcwd() to figure out where the heck we're at.
     *
     * One might think we could skip all this if path doesn't point to a
     * symlink to start with, but that's wrong.  We also want to get rid of
     * any directory symlinks that are present in the given path. We expect
     * getcwd() to give us an accurate, symlink-free path.
     */
    if (!getcwd(orig_wd, MAXPGPATH))
    {
        log_error(errcode_for_file_access(),
                  _("could not identify current directory: %m"));
        return -1;
    }
 
    for (;;)
    {
        char       *lsep;
        int         rllen;
 
        lsep = last_dir_separator(path);
        if (lsep)
        {
            *lsep = '\0';
            if (chdir(path) == -1)
            {
                log_error(errcode_for_file_access(),
                          _("could not change directory to \"%s\": %m"), path);
                return -1;
            }
            fname = lsep + 1;
        }
        else
            fname = path;
 
        if (lstat(fname, &buf) < 0 ||
            !S_ISLNK(buf.st_mode))
            break;
 
        errno = 0;
        rllen = readlink(fname, link_buf, sizeof(link_buf));
        if (rllen < 0 || rllen >= sizeof(link_buf))
        {
            log_error(errcode_for_file_access(),
                      _("could not read symbolic link \"%s\": %m"), fname);
            return -1;
        }
        link_buf[rllen] = '\0';
        strcpy(path, link_buf);
    }
 
    /* must copy final component out of 'path' temporarily */
    strlcpy(link_buf, fname, sizeof(link_buf));
 
    if (!getcwd(path, MAXPGPATH))
    {
        log_error(errcode_for_file_access(),
                  _("could not identify current directory: %m"));
        return -1;
    }
    join_path_components(path, path, link_buf);
    canonicalize_path(path);
 
    if (chdir(orig_wd) == -1)
    {
        log_error(errcode_for_file_access(),
                  _("could not change directory to \"%s\": %m"), orig_wd);
        return -1;
    }
#endif                          /* HAVE_READLINK */
 
    return 0;
}

References _, buf, canonicalize_path(), errcode_for_file_access(), join_path_components(), last_dir_separator(), log_error, lstat, MAXPGPATH, readlink, S_ISLNK, and strlcpy().

Referenced by find_my_exec().

set_pglocale_pgservice()

void set_pglocale_pgservice	(	const char *	argv0,
		const char *	app
	)

Definition at line 460 of file exec.c.

{
    char        path[MAXPGPATH];
    char        my_exec_path[MAXPGPATH];
 
    /* don't set LC_ALL in the backend */
    if (strcmp(app, PG_TEXTDOMAIN("postgres")) != 0)
    {
        setlocale(LC_ALL, "");
 
        /*
         * One could make a case for reproducing here PostmasterMain()'s test
         * for whether the process is multithreaded.  Unlike the postmaster,
         * no frontend program calls sigprocmask() or otherwise provides for
         * mutual exclusion between signal handlers.  While frontends using
         * fork(), if multithreaded, are formally exposed to undefined
         * behavior, we have not witnessed a concrete bug.  Therefore,
         * complaining about multithreading here may be mere pedantry.
         */
    }
 
    if (find_my_exec(argv0, my_exec_path) < 0)
        return;
 
#ifdef ENABLE_NLS
    get_locale_path(my_exec_path, path);
    bindtextdomain(app, path);
    textdomain(app);
    /* set for libpq to use, but don't override existing setting */
    setenv("PGLOCALEDIR", path, 0);
#endif
 
    if (getenv("PGSYSCONFDIR") == NULL)
    {
        get_etc_path(my_exec_path, path);
        /* set for libpq to use */
        setenv("PGSYSCONFDIR", path, 0);
    }
}

References argv0, find_my_exec(), get_etc_path(), get_locale_path(), MAXPGPATH, my_exec_path, PG_TEXTDOMAIN, setenv, and setlocale.

Referenced by main(), and regression_main().

validate_exec()

int validate_exec

(

const char *

path

)

Definition at line 80 of file exec.c.

{
    struct stat buf;
    int         is_r;
    int         is_x;
 
#ifdef WIN32
    char        path_exe[MAXPGPATH + sizeof(".exe") - 1];
 
    /* Win32 requires a .exe suffix for stat() */
    if (strlen(path) >= strlen(".exe") &&
        pg_strcasecmp(path + strlen(path) - strlen(".exe"), ".exe") != 0)
    {
        strlcpy(path_exe, path, sizeof(path_exe) - 4);
        strcat(path_exe, ".exe");
        path = path_exe;
    }
#endif
 
    /*
     * Ensure that the file exists and is a regular file.
     *
     * XXX if you have a broken system where stat() looks at the symlink
     * instead of the underlying file, you lose.
     */
    if (stat(path, &buf) < 0)
        return -1;
 
    if (!S_ISREG(buf.st_mode))
    {
        /*
         * POSIX offers no errno code that's simply "not a regular file".  If
         * it's a directory we can use EISDIR.  Otherwise, it's most likely a
         * device special file, and EPERM (Operation not permitted) isn't too
         * horribly off base.
         */
        errno = S_ISDIR(buf.st_mode) ? EISDIR : EPERM;
        return -1;
    }
 
    /*
     * Ensure that the file is both executable and readable (required for
     * dynamic loading).
     */
#ifndef WIN32
    is_r = (access(path, R_OK) == 0);
    is_x = (access(path, X_OK) == 0);
    /* access() will set errno if it returns -1 */
#else
    is_r = buf.st_mode & S_IRUSR;
    is_x = buf.st_mode & S_IXUSR;
    errno = EACCES;             /* appropriate thing if we return nonzero */
#endif
    return is_x ? (is_r ? 0 : -2) : -1;
}

References buf, MAXPGPATH, pg_strcasecmp(), S_IRUSR, S_ISDIR, S_ISREG, S_IXUSR, stat, and strlcpy().

Referenced by check_exec(), find_my_exec(), and find_other_exec().