path.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <sys/stat.h>
#include <pwd.h>
#include <unistd.h>
#include "pg_config_paths.h"

Include dependency graph for path.c:

Go to the source code of this file.

Macros
#define	IS_PATH_VAR_SEP(ch)   ((ch) == ':')
#define	skip_drive(path)   (path)

Enumerations
enum	canonicalize_state {   ABSOLUTE_PATH_INIT , ABSOLUTE_WITH_N_DEPTH , RELATIVE_PATH_INIT , RELATIVE_WITH_N_DEPTH ,   RELATIVE_WITH_PARENT_REF }

Functions
static void	make_relative_path (char *ret_path, const char *target_path, const char *bin_path, const char *my_exec_path)
static char *	trim_directory (char *path)
static void	trim_trailing_separator (char *path)
static char *	append_subdir_to_path (char *path, char *subdir)
bool	has_drive_prefix (const char *path)
char *	first_dir_separator (const char *filename)
char *	first_path_var_separator (const char *pathlist)
char *	last_dir_separator (const char *filename)
void	make_native_path (char *filename)
void	cleanup_path (char *path)
void	join_path_components (char *ret_path, const char *head, const char *tail)
void	canonicalize_path (char *path)
bool	path_contains_parent_reference (const char *path)
bool	path_is_relative_and_below_cwd (const char *path)
bool	path_is_prefix_of_path (const char *path1, const char *path2)
const char *	get_progname (const char *argv0)
static int	dir_strcmp (const char *s1, const char *s2)
char *	make_absolute_path (const char *path)
void	get_share_path (const char *my_exec_path, char *ret_path)
void	get_etc_path (const char *my_exec_path, char *ret_path)
void	get_include_path (const char *my_exec_path, char *ret_path)
void	get_pkginclude_path (const char *my_exec_path, char *ret_path)
void	get_includeserver_path (const char *my_exec_path, char *ret_path)
void	get_lib_path (const char *my_exec_path, char *ret_path)
void	get_pkglib_path (const char *my_exec_path, char *ret_path)
void	get_locale_path (const char *my_exec_path, char *ret_path)
void	get_doc_path (const char *my_exec_path, char *ret_path)
void	get_html_path (const char *my_exec_path, char *ret_path)
void	get_man_path (const char *my_exec_path, char *ret_path)
bool	get_home_path (char *ret_path)
void	get_parent_directory (char *path)

Macro Definition Documentation

IS_PATH_VAR_SEP

#define IS_PATH_VAR_SEP

(

ch

)

((ch) == ':')

Definition at line 43 of file path.c.

skip_drive

#define skip_drive

(

path

)

(path)

Definition at line 80 of file path.c.

Enumeration Type Documentation

canonicalize_state

enum canonicalize_state

Enumerator
ABSOLUTE_PATH_INIT
ABSOLUTE_WITH_N_DEPTH
RELATIVE_PATH_INIT
RELATIVE_WITH_N_DEPTH
RELATIVE_WITH_PARENT_REF

Definition at line 243 of file path.c.

{
    ABSOLUTE_PATH_INIT,         /* Just past the leading '/' (and Windows
                                 * drive name if any) of an absolute path */
    ABSOLUTE_WITH_N_DEPTH,      /* We collected 'pathdepth' directories in an
                                 * absolute path */
    RELATIVE_PATH_INIT,         /* At start of a relative path */
    RELATIVE_WITH_N_DEPTH,      /* We collected 'pathdepth' directories in a
                                 * relative path */
    RELATIVE_WITH_PARENT_REF,   /* Relative path containing only double-dots */
} canonicalize_state;

Function Documentation

append_subdir_to_path()

static char * append_subdir_to_path ( char *  path, char *  subdir  )

static

Definition at line 1062 of file path.c.

{
    size_t      len = strlen(subdir);
 
    /* No need to copy data if path and subdir are the same. */
    if (path != subdir)
        memmove(path, subdir, len);
 
    return path + len;
}

References len.

Referenced by canonicalize_path().

canonicalize_path()

void canonicalize_path

(

char *

path

)

Definition at line 265 of file path.c.

{
    char       *p,
               *to_p;
    char       *spath;
    char       *parsed;
    char       *unparse;
    bool        was_sep = false;
    canonicalize_state state;
    int         pathdepth = 0;  /* counts collected regular directory names */
 
#ifdef WIN32
 
    /*
     * The Windows command processor will accept suitably quoted paths with
     * forward slashes, but barfs badly with mixed forward and back slashes.
     */
    for (p = path; *p; p++)
    {
        if (*p == '\\')
            *p = '/';
    }
 
    /*
     * In Win32, if you do: prog.exe "a b" "\c\d\" the system will pass \c\d"
     * as argv[2], so trim off trailing quote.
     */
    if (p > path && *(p - 1) == '"')
        *(p - 1) = '/';
#endif
 
    /*
     * Removing the trailing slash on a path means we never get ugly double
     * trailing slashes. Also, Win32 can't stat() a directory with a trailing
     * slash. Don't remove a leading slash, though.
     */
    trim_trailing_separator(path);
 
    /*
     * Remove duplicate adjacent separators
     */
    p = path;
#ifdef WIN32
    /* Don't remove leading double-slash on Win32 */
    if (*p)
        p++;
#endif
    to_p = p;
    for (; *p; p++, to_p++)
    {
        /* Handle many adjacent slashes, like "/a///b" */
        while (*p == '/' && was_sep)
            p++;
        if (to_p != p)
            *to_p = *p;
        was_sep = (*p == '/');
    }
    *to_p = '\0';
 
    /*
     * Remove any uses of "." and process ".." ourselves
     *
     * Note that "/../.." should reduce to just "/", while "../.." has to be
     * kept as-is.  Also note that we want a Windows drive spec to be visible
     * to trim_directory(), but it's not part of the logic that's looking at
     * the name components; hence distinction between path and spath.
     *
     * This loop overwrites the path in-place.  This is safe since we'll never
     * make the path longer.  "unparse" points to where we are reading the
     * path, "parse" to where we are writing.
     */
    spath = skip_drive(path);
    if (*spath == '\0')
        return;                 /* empty path is returned as-is */
 
    if (*spath == '/')
    {
        state = ABSOLUTE_PATH_INIT;
        /* Skip the leading slash for absolute path */
        parsed = unparse = (spath + 1);
    }
    else
    {
        state = RELATIVE_PATH_INIT;
        parsed = unparse = spath;
    }
 
    while (*unparse != '\0')
    {
        char       *unparse_next;
        bool        is_double_dot;
 
        /* Split off this dir name, and set unparse_next to the next one */
        unparse_next = unparse;
        while (*unparse_next && *unparse_next != '/')
            unparse_next++;
        if (*unparse_next != '\0')
            *unparse_next++ = '\0';
 
        /* Identify type of this dir name */
        if (strcmp(unparse, ".") == 0)
        {
            /* We can ignore "." components in all cases */
            unparse = unparse_next;
            continue;
        }
 
        if (strcmp(unparse, "..") == 0)
            is_double_dot = true;
        else
        {
            /* adjacent separators were eliminated above */
            Assert(*unparse != '\0');
            is_double_dot = false;
        }
 
        switch (state)
        {
            case ABSOLUTE_PATH_INIT:
                /* We can ignore ".." immediately after / */
                if (!is_double_dot)
                {
                    /* Append first dir name (we already have leading slash) */
                    parsed = append_subdir_to_path(parsed, unparse);
                    state = ABSOLUTE_WITH_N_DEPTH;
                    pathdepth++;
                }
                break;
            case ABSOLUTE_WITH_N_DEPTH:
                if (is_double_dot)
                {
                    /* Remove last parsed dir */
                    /* (trim_directory won't remove the leading slash) */
                    *parsed = '\0';
                    parsed = trim_directory(path);
                    if (--pathdepth == 0)
                        state = ABSOLUTE_PATH_INIT;
                }
                else
                {
                    /* Append normal dir */
                    *parsed++ = '/';
                    parsed = append_subdir_to_path(parsed, unparse);
                    pathdepth++;
                }
                break;
            case RELATIVE_PATH_INIT:
                if (is_double_dot)
                {
                    /* Append irreducible double-dot (..) */
                    parsed = append_subdir_to_path(parsed, unparse);
                    state = RELATIVE_WITH_PARENT_REF;
                }
                else
                {
                    /* Append normal dir */
                    parsed = append_subdir_to_path(parsed, unparse);
                    state = RELATIVE_WITH_N_DEPTH;
                    pathdepth++;
                }
                break;
            case RELATIVE_WITH_N_DEPTH:
                if (is_double_dot)
                {
                    /* Remove last parsed dir */
                    *parsed = '\0';
                    parsed = trim_directory(path);
                    if (--pathdepth == 0)
                    {
                        /*
                         * If the output path is now empty, we're back to the
                         * INIT state.  However, we could have processed a
                         * path like "../dir/.." and now be down to "..", in
                         * which case enter the correct state for that.
                         */
                        if (parsed == spath)
                            state = RELATIVE_PATH_INIT;
                        else
                            state = RELATIVE_WITH_PARENT_REF;
                    }
                }
                else
                {
                    /* Append normal dir */
                    *parsed++ = '/';
                    parsed = append_subdir_to_path(parsed, unparse);
                    pathdepth++;
                }
                break;
            case RELATIVE_WITH_PARENT_REF:
                if (is_double_dot)
                {
                    /* Append next irreducible double-dot (..) */
                    *parsed++ = '/';
                    parsed = append_subdir_to_path(parsed, unparse);
                }
                else
                {
                    /* Append normal dir */
                    *parsed++ = '/';
                    parsed = append_subdir_to_path(parsed, unparse);
 
                    /*
                     * We can now start counting normal dirs.  But if later
                     * double-dots make us remove this dir again, we'd better
                     * revert to RELATIVE_WITH_PARENT_REF not INIT state.
                     */
                    state = RELATIVE_WITH_N_DEPTH;
                    pathdepth = 1;
                }
                break;
        }
 
        unparse = unparse_next;
    }
 
    /*
     * If our output path is empty at this point, insert ".".  We don't want
     * to do this any earlier because it'd result in an extra dot in corner
     * cases such as "../dir/..".  Since we rejected the wholly-empty-path
     * case above, there is certainly room.
     */
    if (parsed == spath)
        *parsed++ = '.';
 
    /* And finally, ensure the output path is nul-terminated. */
    *parsed = '\0';
}

References ABSOLUTE_PATH_INIT, ABSOLUTE_WITH_N_DEPTH, append_subdir_to_path(), Assert, RELATIVE_PATH_INIT, RELATIVE_WITH_N_DEPTH, RELATIVE_WITH_PARENT_REF, skip_drive, trim_directory(), and trim_trailing_separator().

Referenced by AbsoluteConfigLocation(), add_tablespace_mapping(), adjust_data_dir(), check_canonical_path(), check_required_directory(), convert_and_check_filename(), create_script_for_old_cluster_deletion(), create_xlog_or_symlink(), CreateTableSpace(), do_copy(), exec_command_edit(), exec_command_write(), find_in_dynamic_libpath(), find_my_exec(), find_other_exec(), get_tablespace_mapping(), GetConfFilesInDir(), main(), make_absolute_path(), make_relative_path(), member_verify_header(), normalize_exec_path(), parseCommandLine(), process_file(), scan_for_existing_tablespaces(), setup(), setup_bin_paths(), setup_pgdata(), SplitDirectoriesString(), tablespace_list_append(), and test_canonicalize_path().

cleanup_path()

void cleanup_path

(

char *

path

)

Definition at line 187 of file path.c.

{
#ifdef WIN32
    char       *ptr;
 
    /*
     * GetShortPathName() will fail if the path does not exist, or short names
     * are disabled on this file system.  In both cases, we just return the
     * original path.  This is particularly useful for --sysconfdir, which
     * might not exist.
     */
    GetShortPathName(path, path, MAXPGPATH - 1);
 
    /* Replace '\' with '/' */
    for (ptr = path; *ptr; ptr++)
    {
        if (*ptr == '\\')
            *ptr = '/';
    }
#endif
}

References MAXPGPATH.

Referenced by get_configdata().

dir_strcmp()

static int dir_strcmp ( const char *  s1, const char *  s2  )

static

Definition at line 613 of file path.c.

{
    while (*s1 && *s2)
    {
        if (
#ifndef WIN32
            *s1 != *s2
#else
        /* On windows, paths are case-insensitive */
            pg_tolower((unsigned char) *s1) != pg_tolower((unsigned char) *s2)
#endif
            && !(IS_DIR_SEP(*s1) && IS_DIR_SEP(*s2)))
            return (int) *s1 - (int) *s2;
        s1++, s2++;
    }
    if (*s1)
        return 1;               /* s1 longer */
    if (*s2)
        return -1;              /* s2 longer */
    return 0;
}

References IS_DIR_SEP, pg_tolower(), s1, and s2.

Referenced by make_relative_path().

first_dir_separator()

char * first_dir_separator

(

const char *

filename

)

Definition at line 105 of file path.c.

{
    const char *p;
 
    for (p = skip_drive(filename); *p; p++)
        if (IS_DIR_SEP(*p))
            return unconstify(char *, p);
    return NULL;
}

References filename, IS_DIR_SEP, skip_drive, and unconstify.

Referenced by check_restricted_library_name(), check_valid_extension_name(), check_valid_version_name(), expand_dynamic_library_name(), find_in_dynamic_libpath(), find_my_exec(), load_libraries(), and substitute_libpath_macro().

first_path_var_separator()

char * first_path_var_separator

(

const char *

pathlist

)

Definition at line 122 of file path.c.

{
    const char *p;
 
    /* skip_drive is not needed */
    for (p = pathlist; *p; p++)
        if (IS_PATH_VAR_SEP(*p))
            return unconstify(char *, p);
    return NULL;
}

References IS_PATH_VAR_SEP, and unconstify.

Referenced by find_in_dynamic_libpath(), and find_my_exec().

get_doc_path()

void get_doc_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 897 of file path.c.

{
    make_relative_path(ret_path, DOCDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata().

get_etc_path()

void get_etc_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 834 of file path.c.

{
    make_relative_path(ret_path, SYSCONFDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), process_psqlrc(), and set_pglocale_pgservice().

get_home_path()

bool get_home_path

(

char *

ret_path

)

Definition at line 928 of file path.c.

{
#ifndef WIN32
    /*
     * We first consult $HOME.  If that's unset, try to get the info from
     * <pwd.h>.
     */
    const char *home;
 
    home = getenv("HOME");
    if (home && home[0])
    {
        strlcpy(ret_path, home, MAXPGPATH);
        return true;
    }
    else
    {
        struct passwd pwbuf;
        struct passwd *pw;
        char        buf[1024];
        int         rc;
 
        rc = getpwuid_r(geteuid(), &pwbuf, buf, sizeof buf, &pw);
        if (rc != 0 || !pw)
            return false;
        strlcpy(ret_path, pw->pw_dir, MAXPGPATH);
        return true;
    }
#else
    char       *tmppath;
 
    /*
     * Note: We use getenv() here because the more modern SHGetFolderPath()
     * would force the backend to link with shell32.lib, which eats valuable
     * desktop heap.  XXX This function is used only in psql, which already
     * brings in shell32 via libpq.  Moving this function to its own file
     * would keep it out of the backend, freeing it from this concern.
     */
    tmppath = getenv("APPDATA");
    if (!tmppath)
        return false;
    snprintf(ret_path, MAXPGPATH, "%s/postgresql", tmppath);
    return true;
#endif
}

References buf, MAXPGPATH, snprintf, and strlcpy().

Referenced by expand_tilde(), initializeInput(), and process_psqlrc().

get_html_path()

void get_html_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 906 of file path.c.

{
    make_relative_path(ret_path, HTMLDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata().

get_include_path()

void get_include_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 843 of file path.c.

{
    make_relative_path(ret_path, INCLUDEDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), and main().

get_includeserver_path()

void get_includeserver_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 861 of file path.c.

{
    make_relative_path(ret_path, INCLUDEDIRSERVER, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata().

get_lib_path()

void get_lib_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 870 of file path.c.

{
    make_relative_path(ret_path, LIBDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata().

get_locale_path()

void get_locale_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 888 of file path.c.

{
    make_relative_path(ret_path, LOCALEDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), pg_bindtextdomain(), and set_pglocale_pgservice().

get_man_path()

void get_man_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 915 of file path.c.

{
    make_relative_path(ret_path, MANDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata().

get_parent_directory()

void get_parent_directory

(

char *

path

)

Definition at line 991 of file path.c.

{
    trim_directory(path);
}

References trim_directory().

Referenced by AbsoluteConfigLocation(), dbase_redo(), destroy_tablespace_directories(), fsync_parent_path(), main(), and process_file().

get_pkginclude_path()

void get_pkginclude_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 852 of file path.c.

{
    make_relative_path(ret_path, PKGINCLUDEDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), and main().

get_pkglib_path()

void get_pkglib_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 879 of file path.c.

{
    make_relative_path(ret_path, PKGLIBDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), getInstallationPaths(), and InitStandaloneProcess().

get_progname()

const char * get_progname

(

const char *

argv0

)

Definition at line 575 of file path.c.

{
    const char *nodir_name;
    char       *progname;
 
    nodir_name = last_dir_separator(argv0);
    if (nodir_name)
        nodir_name++;
    else
        nodir_name = skip_drive(argv0);
 
    /*
     * Make a copy in case argv[0] is modified by ps_status. Leaks memory, but
     * called only once.
     */
    progname = strdup(nodir_name);
    if (progname == NULL)
    {
        fprintf(stderr, "%s: out of memory\n", nodir_name);
        abort();                /* This could exit the postmaster */
    }
 
#if defined(__CYGWIN__) || defined(WIN32)
    /* strip ".exe" suffix, regardless of case */
    if (strlen(progname) > sizeof(EXE) - 1 &&
        pg_strcasecmp(progname + strlen(progname) - (sizeof(EXE) - 1), EXE) == 0)
        progname[strlen(progname) - (sizeof(EXE) - 1)] = '\0';
#endif
 
    return progname;
}

References argv0, EXE, fprintf, last_dir_separator(), pg_strcasecmp(), progname, and skip_drive.

Referenced by get_opts(), handle_help_version_opts(), main(), parseCommandLine(), pg_logging_init(), and regression_main().

get_share_path()

void get_share_path	(	const char *	my_exec_path,
		char *	ret_path
	)

Definition at line 825 of file path.c.

{
    make_relative_path(ret_path, PGSHAREDIR, PGBINDIR, my_exec_path);
}

References make_relative_path(), and my_exec_path.

Referenced by get_configdata(), get_extension_control_directory(), get_extension_control_filename(), get_extension_script_directory(), get_tsearch_config_filename(), ParseTzFile(), pg_TZDIR(), and setup_bin_paths().

has_drive_prefix()

bool has_drive_prefix

(

const char *

path

)

Definition at line 89 of file path.c.

{
#ifdef WIN32
    return skip_drive(path) != path;
#else
    return false;
#endif
}

References skip_drive.

Referenced by process_file().

join_path_components()

void join_path_components	(	char *	ret_path,
		const char *	head,
		const char *	tail
	)

Definition at line 220 of file path.c.

{
    if (ret_path != head)
        strlcpy(ret_path, head, MAXPGPATH);
 
    /*
     * We used to try to simplify some cases involving "." and "..", but now
     * we just leave that to be done by canonicalize_path() later.
     */
 
    if (*tail)
    {
        /* only separate with slash if head wasn't empty */
        snprintf(ret_path + strlen(ret_path), MAXPGPATH - strlen(ret_path),
                 "%s%s",
                 (*(skip_drive(head)) != '\0') ? "/" : "",
                 tail);
    }
}

References MAXPGPATH, skip_drive, snprintf, and strlcpy().

Referenced by AbsoluteConfigLocation(), find_my_exec(), GetConfFilesInDir(), main(), make_relative_path(), and process_file().

last_dir_separator()

char * last_dir_separator

(

const char *

filename

)

Definition at line 140 of file path.c.

{
    const char *p,
               *ret = NULL;
 
    for (p = skip_drive(filename); *p; p++)
        if (IS_DIR_SEP(*p))
            ret = p;
    return unconstify(char *, ret);
}

References filename, IS_DIR_SEP, skip_drive, and unconstify.

Referenced by check_file_excluded(), ECPGconnect(), find_other_exec(), get_progname(), main(), sendDir(), setup(), setup_bin_paths(), and should_allow_existing_directory().

make_absolute_path()

char * make_absolute_path

(

const char *

path

)

Definition at line 730 of file path.c.

{
    char       *new;
 
    /* Returning null for null input is convenient for some callers */
    if (path == NULL)
        return NULL;
 
    if (!is_absolute_path(path))
    {
        char       *buf;
        size_t      buflen;
 
        buflen = MAXPGPATH;
        for (;;)
        {
            buf = malloc(buflen);
            if (!buf)
            {
#ifndef FRONTEND
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of memory")));
#else
                fprintf(stderr, _("out of memory\n"));
                return NULL;
#endif
            }
 
            if (getcwd(buf, buflen))
                break;
            else if (errno == ERANGE)
            {
                free(buf);
                buflen *= 2;
                continue;
            }
            else
            {
                int         save_errno = errno;
 
                free(buf);
                errno = save_errno;
#ifndef FRONTEND
                elog(ERROR, "could not get current working directory: %m");
#else
                fprintf(stderr, _("could not get current working directory: %m\n"));
                return NULL;
#endif
            }
        }
 
        new = malloc(strlen(buf) + strlen(path) + 2);
        if (!new)
        {
            free(buf);
#ifndef FRONTEND
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
#else
            fprintf(stderr, _("out of memory\n"));
            return NULL;
#endif
        }
        sprintf(new, "%s/%s", buf, path);
        free(buf);
    }
    else
    {
        new = strdup(path);
        if (!new)
        {
#ifndef FRONTEND
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
#else
            fprintf(stderr, _("out of memory\n"));
            return NULL;
#endif
        }
    }
 
    /* Make sure punctuation is canonical, too */
    canonicalize_path(new);
 
    return new;
}

References _, buf, canonicalize_path(), elog, ereport, errcode(), errmsg(), ERROR, fprintf, free, is_absolute_path, malloc, MAXPGPATH, and sprintf.

Referenced by regression_main(), SelectConfigFiles(), and SetDataDir().

make_native_path()

void make_native_path

(

char *

filename

)

Definition at line 168 of file path.c.

{
#ifdef WIN32
    char       *p;
 
    for (p = filename; *p; p++)
        if (*p == '/')
            *p = '\\';
#endif
}

References filename.

Referenced by BuildRestoreCommand(), main(), and shell_archive_file().

make_relative_path()

static void make_relative_path ( char *  ret_path, const char *  target_path, const char *  bin_path, const char *  my_exec_path  )

static

Definition at line 661 of file path.c.

{
    int         prefix_len;
    int         tail_start;
    int         tail_len;
    int         i;
 
    /*
     * Determine the common prefix --- note we require it to end on a
     * directory separator, consider eg '/usr/lib' and '/usr/libexec'.
     */
    prefix_len = 0;
    for (i = 0; target_path[i] && bin_path[i]; i++)
    {
        if (IS_DIR_SEP(target_path[i]) && IS_DIR_SEP(bin_path[i]))
            prefix_len = i + 1;
        else if (target_path[i] != bin_path[i])
            break;
    }
    if (prefix_len == 0)
        goto no_match;          /* no common prefix? */
    tail_len = strlen(bin_path) - prefix_len;
 
    /*
     * Set up my_exec_path without the actual executable name, and
     * canonicalize to simplify comparison to bin_path.
     */
    strlcpy(ret_path, my_exec_path, MAXPGPATH);
    trim_directory(ret_path);   /* remove my executable name */
    canonicalize_path(ret_path);
 
    /*
     * Tail match?
     */
    tail_start = (int) strlen(ret_path) - tail_len;
    if (tail_start > 0 &&
        IS_DIR_SEP(ret_path[tail_start - 1]) &&
        dir_strcmp(ret_path + tail_start, bin_path + prefix_len) == 0)
    {
        ret_path[tail_start] = '\0';
        trim_trailing_separator(ret_path);
        join_path_components(ret_path, ret_path, target_path + prefix_len);
        canonicalize_path(ret_path);
        return;
    }
 
no_match:
    strlcpy(ret_path, target_path, MAXPGPATH);
    canonicalize_path(ret_path);
}

References bin_path, canonicalize_path(), dir_strcmp(), i, IS_DIR_SEP, join_path_components(), MAXPGPATH, my_exec_path, strlcpy(), trim_directory(), and trim_trailing_separator().

Referenced by get_doc_path(), get_etc_path(), get_html_path(), get_include_path(), get_includeserver_path(), get_lib_path(), get_locale_path(), get_man_path(), get_pkginclude_path(), get_pkglib_path(), and get_share_path().

path_contains_parent_reference()

bool path_contains_parent_reference

(

const char *

path

)

Definition at line 500 of file path.c.

{
    /*
     * Once canonicalized, an absolute path cannot contain any ".." at all,
     * while a relative path could contain ".."(s) only at the start.  So it
     * is sufficient to check the start of the path, after skipping any
     * Windows drive/network specifier.
     */
    path = skip_drive(path);    /* C: shouldn't affect our conclusion */
 
    if (path[0] == '.' &&
        path[1] == '.' &&
        (path[2] == '\0' || path[2] == '/'))
        return true;
 
    return false;
}

References skip_drive.

Referenced by path_is_relative_and_below_cwd().

path_is_prefix_of_path()

bool path_is_prefix_of_path	(	const char *	path1,
		const char *	path2
	)

Definition at line 560 of file path.c.

{
    int         path1_len = strlen(path1);
 
    if (strncmp(path1, path2, path1_len) == 0 &&
        (IS_DIR_SEP(path2[path1_len]) || path2[path1_len] == '\0'))
        return true;
    return false;
}

References IS_DIR_SEP.

Referenced by convert_and_check_filename(), create_script_for_old_cluster_deletion(), CreateTableSpace(), and parseCommandLine().

path_is_relative_and_below_cwd()

bool path_is_relative_and_below_cwd

(

const char *

path

)

Definition at line 527 of file path.c.

{
    if (is_absolute_path(path))
        return false;
    /* don't allow anything above the cwd */
    else if (path_contains_parent_reference(path))
        return false;
#ifdef WIN32
 
    /*
     * On Win32, a drive letter _not_ followed by a slash, e.g. 'E:abc', is
     * relative to the cwd on that drive, or the drive's root directory if
     * that drive has no cwd.  Because the path itself cannot tell us which is
     * the case, we have to assume the worst, i.e. that it is not below the
     * cwd.  We could use GetFullPathName() to find the full path but that
     * could change if the current directory for the drive changes underneath
     * us, so we just disallow it.
     */
    else if (isalpha((unsigned char) path[0]) && path[1] == ':' &&
             !IS_DIR_SEP(path[2]))
        return false;
#endif
    else
        return true;
}

References is_absolute_path, IS_DIR_SEP, and path_contains_parent_reference().

Referenced by convert_and_check_filename().

trim_directory()

static char * trim_directory ( char *  path )

static

Definition at line 1008 of file path.c.

{
    char       *p;
 
    path = skip_drive(path);
 
    if (path[0] == '\0')
        return path;
 
    /* back up over trailing slash(es) */
    for (p = path + strlen(path) - 1; IS_DIR_SEP(*p) && p > path; p--)
        ;
    /* back up over directory name */
    for (; !IS_DIR_SEP(*p) && p > path; p--)
        ;
    /* if multiple slashes before directory name, remove 'em all */
    for (; p > path && IS_DIR_SEP(*(p - 1)); p--)
        ;
    /* don't erase a leading slash */
    if (p == path && IS_DIR_SEP(*p))
        p++;
    *p = '\0';
    return p;
}

References IS_DIR_SEP, and skip_drive.

Referenced by canonicalize_path(), get_parent_directory(), and make_relative_path().

trim_trailing_separator()

static void trim_trailing_separator ( char *  path )

static

Definition at line 1040 of file path.c.

{
    char       *p;
 
    path = skip_drive(path);
    p = path + strlen(path);
    if (p > path)
        for (p--; p > path && IS_DIR_SEP(*p); p--)
            *p = '\0';
}

References IS_DIR_SEP, and skip_drive.

Referenced by canonicalize_path(), and make_relative_path().