port.h File Reference

#include <ctype.h>
#include <netinet/in.h>
#include <arpa/inet.h>

Include dependency graph for port.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PGINVALID_SOCKET   (-1)
#define	IS_DIR_SEP(ch)   ((ch) == '/')
#define	is_absolute_path(filename)
#define	ALL_CONNECTION_FAILURE_ERRNOS
#define	PG_BACKEND_VERSIONSTR   "postgres (PostgreSQL) " PG_VERSION "\n"
#define	EXE   ""
#define	DEVNULL   "/dev/null"
#define	USE_REPL_SNPRINTF   1
#define	vsnprintf   pg_vsnprintf
#define	snprintf   pg_snprintf
#define	vsprintf   pg_vsprintf
#define	sprintf   pg_sprintf
#define	vfprintf   pg_vfprintf
#define	fprintf   pg_fprintf
#define	vprintf   pg_vprintf
#define	printf(...)   pg_printf(__VA_ARGS__)
#define	strerror   pg_strerror
#define	strerror_r   pg_strerror_r
#define	PG_STRERROR_R_BUFLEN   256 /* Recommended buffer size for strerror_r */
#define	TIMEZONE_GLOBAL   timezone
#define	TZNAME_GLOBAL   tzname
#define	closesocket   close
#define	PG_IOLBF   _IOLBF
#define	pgoff_t   off_t
#define	RTLD_NOW   1
#define	RTLD_GLOBAL   0
#define	qsort(a, b, c, d)   pg_qsort(a,b,c,d)
#define	pg_backend_random   pg_strong_random

Typedefs
typedef int	pgsocket
typedef unsigned int	socklen_t
typedef int(*	qsort_arg_comparator) (const void *a, const void *b, void *arg)
typedef void(*	pqsigfunc) (int signo)

Functions
bool	pg_set_noblock (pgsocket sock)
bool	pg_set_block (pgsocket sock)
bool	has_drive_prefix (const char *filename)
char *	first_dir_separator (const char *filename)
char *	last_dir_separator (const char *filename)
char *	first_path_var_separator (const char *pathlist)
void	join_path_components (char *ret_path, const char *head, const char *tail)
void	canonicalize_path (char *path)
void	make_native_path (char *path)
void	cleanup_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)
char *	make_absolute_path (const char *path)
const char *	get_progname (const char *argv0)
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)
char **	pgfnames (const char *path)
void	pgfnames_cleanup (char **filenames)
void	set_pglocale_pgservice (const char *argv0, const char *app)
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)
void	pg_usleep (long microsec)
int	pg_strcasecmp (const char *s1, const char *s2)
int	pg_strncasecmp (const char *s1, const char *s2, size_t n)
unsigned char	pg_toupper (unsigned char ch)
unsigned char	pg_tolower (unsigned char ch)
unsigned char	pg_ascii_toupper (unsigned char ch)
unsigned char	pg_ascii_tolower (unsigned char ch)
int	pg_vsnprintf (char *str, size_t count, const char *fmt, va_list args)
int	pg_snprintf (char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
int int	pg_vsprintf (char *str, const char *fmt, va_list args)
int	pg_sprintf (char *str, const char *fmt,...) pg_attribute_printf(2
int int	pg_vfprintf (FILE *stream, const char *fmt, va_list args)
int	pg_fprintf (FILE *stream, const char *fmt,...) pg_attribute_printf(2
int int	pg_vprintf (const char *fmt, va_list args)
int	pg_printf (const char *fmt,...) pg_attribute_printf(1
int	pg_strfromd (char *str, size_t count, int precision, double value)
char *	pg_strerror (int errnum)
char *	pg_strerror_r (int errnum, char *buf, size_t buflen)
const char *	pg_strsignal (int signum)
int	pclose_check (FILE *stream)
bool	rmtree (const char *path, bool rmtopdir)
int	fls (int mask)
int	getpeereid (int sock, uid_t *uid, gid_t *gid)
void	explicit_bzero (void *buf, size_t len)
float	strtof (const char *nptr, char **endptr)
int	link (const char *src, const char *dst)
char *	mkdtemp (char *path)
int	inet_aton (const char *cp, struct in_addr *addr)
ssize_t	pg_pread (int fd, void *buf, size_t nbyte, off_t offset)
ssize_t	pg_pwrite (int fd, const void *buf, size_t nbyte, off_t offset)
size_t	strlcat (char *dst, const char *src, size_t siz)
size_t	strlcpy (char *dst, const char *src, size_t siz)
size_t	strnlen (const char *str, size_t maxlen)
int	setenv (const char *name, const char *value, int overwrite)
int	unsetenv (const char *name)
void *	dlopen (const char *file, int mode)
void *	dlsym (void *handle, const char *symbol)
int	dlclose (void *handle)
char *	dlerror (void)
bool	pg_get_user_name (uid_t user_id, char *buffer, size_t buflen)
bool	pg_get_user_home_dir (uid_t user_id, char *buffer, size_t buflen)
void	pg_qsort (void *base, size_t nel, size_t elsize, int(*cmp)(const void *, const void *))
int	pg_qsort_strcmp (const void *a, const void *b)
void	qsort_arg (void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)
void *	bsearch_arg (const void *key, const void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *, void *), void *arg)
int	pg_get_encoding_from_locale (const char *ctype, bool write_message)
char *	pg_inet_net_ntop (int af, const void *src, int bits, char *dst, size_t size)
void	pg_strong_random_init (void)
bool	pg_strong_random (void *buf, size_t len)
int	pg_check_dir (const char *dir)
int	pg_mkdir_p (char *path, int omode)
pqsigfunc	pqsignal (int signo, pqsigfunc func)
char *	escape_single_quotes_ascii (const char *src)
char *	wait_result_to_str (int exit_status)
bool	wait_result_is_signal (int exit_status, int signum)
bool	wait_result_is_any_signal (int exit_status, bool include_command_not_found)

Macro Definition Documentation

ALL_CONNECTION_FAILURE_ERRNOS

#define ALL_CONNECTION_FAILURE_ERRNOS

Value:

    EPIPE: \
    case ECONNRESET: \
    case ECONNABORTED: \
    case EHOSTDOWN: \
    case EHOSTUNREACH: \
    case ENETDOWN: \
    case ENETRESET: \
    case ENETUNREACH: \
    case ETIMEDOUT

Definition at line 117 of file port.h.

closesocket

#define closesocket   close

Definition at line 342 of file port.h.

DEVNULL

#define DEVNULL   "/dev/null"

Definition at line 156 of file port.h.

EXE

#define EXE   ""

Definition at line 150 of file port.h.

fprintf

#define fprintf   pg_fprintf

Definition at line 229 of file port.h.

is_absolute_path

#define is_absolute_path

(

filename

)

Value:

( \
    IS_DIR_SEP((filename)[0]) \
)

Definition at line 89 of file port.h.

IS_DIR_SEP

#define IS_DIR_SEP

(

ch

)

((ch) == '/')

Definition at line 87 of file port.h.

pg_backend_random

#define pg_backend_random   pg_strong_random

Definition at line 526 of file port.h.

PG_BACKEND_VERSIONSTR

#define PG_BACKEND_VERSIONSTR   "postgres (PostgreSQL) " PG_VERSION "\n"

Definition at line 139 of file port.h.

PG_IOLBF

#define PG_IOLBF   _IOLBF

Definition at line 354 of file port.h.

PG_STRERROR_R_BUFLEN

#define PG_STRERROR_R_BUFLEN   256 /* Recommended buffer size for strerror_r */

Definition at line 243 of file port.h.

PGINVALID_SOCKET

#define PGINVALID_SOCKET   (-1)

Definition at line 31 of file port.h.

pgoff_t

#define pgoff_t   off_t

Definition at line 366 of file port.h.

printf

#define printf

(

...

)

pg_printf(__VA_ARGS__)

Definition at line 231 of file port.h.

qsort

#define qsort	(		a,
			b,
			c,
			d
	)		pg_qsort(a,b,c,d)

Definition at line 495 of file port.h.

RTLD_GLOBAL

#define RTLD_GLOBAL   0

Definition at line 482 of file port.h.

RTLD_NOW

#define RTLD_NOW   1

Definition at line 474 of file port.h.

snprintf

#define snprintf   pg_snprintf

Definition at line 225 of file port.h.

sprintf

#define sprintf   pg_sprintf

Definition at line 227 of file port.h.

strerror

#define strerror   pg_strerror

Definition at line 238 of file port.h.

strerror_r

#define strerror_r   pg_strerror_r

Definition at line 242 of file port.h.

TIMEZONE_GLOBAL

#define TIMEZONE_GLOBAL   timezone

Definition at line 255 of file port.h.

TZNAME_GLOBAL

#define TZNAME_GLOBAL   tzname

Definition at line 256 of file port.h.

USE_REPL_SNPRINTF

#define USE_REPL_SNPRINTF   1

Definition at line 175 of file port.h.

vfprintf

#define vfprintf   pg_vfprintf

Definition at line 228 of file port.h.

vprintf

#define vprintf   pg_vprintf

Definition at line 230 of file port.h.

vsnprintf

#define vsnprintf   pg_vsnprintf

Definition at line 224 of file port.h.

vsprintf

#define vsprintf   pg_vsprintf

Definition at line 226 of file port.h.

Typedef Documentation

pgsocket

typedef int pgsocket

Definition at line 29 of file port.h.

pqsigfunc

typedef void(* pqsigfunc) (int signo)

Definition at line 535 of file port.h.

qsort_arg_comparator

typedef int(* qsort_arg_comparator) (const void *a, const void *b, void *arg)

Definition at line 497 of file port.h.

socklen_t

typedef unsigned int socklen_t

Definition at line 40 of file port.h.

Function Documentation

bsearch_arg()

void* bsearch_arg	(	const void *	key,
		const void *	base,
		size_t	nmemb,
		size_t	size,
		int(*)(const void *, const void *, void *)	compar,
		void *	arg
	)

Definition at line 55 of file bsearch_arg.c.

{
    const char *base = (const char *) base0;
    int         lim,
                cmp;
    const void *p;
 
    for (lim = nmemb; lim != 0; lim >>= 1)
    {
        p = base + (lim >> 1) * size;
        cmp = (*compar) (key, p, arg);
        if (cmp == 0)
            return (void *) p;
        if (cmp > 0)
        {                       /* key > p: move right */
            base = (const char *) p + size;
            lim--;
        }                       /* else move left */
    }
    return (NULL);
}

References arg, cmp(), and sort-test::key.

Referenced by AssertCheckRanges(), range_contains_value(), statext_mcv_build(), and statext_mcv_serialize().

canonicalize_path()

void canonicalize_path

(

char *

path

)

Definition at line 264 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 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(), main(), make_absolute_path(), make_relative_path(), parseCommandLine(), process_file(), resolve_symlinks(), setup(), setup_bin_paths(), setup_pgdata(), SplitDirectoriesString(), tablespace_list_append(), test_canonicalize_path(), and tokenize_inc_file().

cleanup_path()

void cleanup_path

(

char *

path

)

Definition at line 186 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().

dlclose()

int dlclose

(

void *

handle

)

Referenced by internal_load_library().

dlerror()

char* dlerror

(

void

)

Referenced by internal_load_library().

dlopen()

void* dlopen	(	const char *	file,
		int	mode
	)

Referenced by internal_load_library().

dlsym()

void* dlsym	(	void *	handle,
		const char *	symbol
	)

Referenced by internal_load_library(), load_external_function(), and lookup_external_function().

escape_single_quotes_ascii()

char* escape_single_quotes_ascii

(

const char *

src

)

Definition at line 33 of file quotes.c.

{
    int         len = strlen(src),
                i,
                j;
    char       *result = malloc(len * 2 + 1);
 
    if (!result)
        return NULL;
 
    for (i = 0, j = 0; i < len; i++)
    {
        if (SQL_STR_DOUBLE(src[i], true))
            result[j++] = src[i];
        result[j++] = src[i];
    }
    result[j] = '\0';
    return result;
}

References i, j, len, malloc, and SQL_STR_DOUBLE.

Referenced by escape_quotes(), and write_auto_conf_file().

explicit_bzero()

void explicit_bzero	(	void *	buf,
		size_t	len
	)

Definition at line 50 of file explicit_bzero.c.

{
    bzero_p(buf, len);
}

References buf, bzero_p, and len.

Referenced by freePGconn(), passwordFromFile(), pg_cryptohash_create(), pg_cryptohash_free(), pg_hmac_create(), pg_hmac_free(), and run_ssl_passphrase_command().

find_my_exec()

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

Definition at line 140 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\""), 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\""),
                              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 335 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().

first_dir_separator()

char* first_dir_separator

(

const char *

filename

)

Definition at line 104 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 121 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().

fls()

int fls

(

int

mask

)

Definition at line 55 of file fls.c.

{
    int         bit;
 
    if (mask == 0)
        return (0);
    for (bit = 1; mask != 1; bit++)
        mask = (unsigned int) mask >> 1;
    return (bit);
}

References bit().

Referenced by _hash_get_oldblock_from_newbucket(), add_paths_to_append_rel(), and generate_union_paths().

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 == NULL || home[0] == '\0')
        return pg_get_user_home_dir(geteuid(), ret_path, MAXPGPATH);
    strlcpy(ret_path, home, 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 MAXPGPATH, pg_get_user_home_dir(), 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 977 of file path.c.

{
    trim_directory(path);
}

References trim_directory().

Referenced by destroy_tablespace_directories(), fsync_parent_path(), main(), process_file(), TablespaceCreateDbspace(), and tokenize_inc_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 574 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().

getpeereid()

int getpeereid	(	int	sock,
		uid_t *	uid,
		gid_t *	gid
	)

Definition at line 35 of file getpeereid.c.

{
#if defined(SO_PEERCRED)
    /* Linux: use getsockopt(SO_PEERCRED) */
    struct ucred peercred;
    socklen_t   so_len = sizeof(peercred);
 
    if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &peercred, &so_len) != 0 ||
        so_len != sizeof(peercred))
        return -1;
    *uid = peercred.uid;
    *gid = peercred.gid;
    return 0;
#elif defined(LOCAL_PEERCRED)
    /* Debian with FreeBSD kernel: use getsockopt(LOCAL_PEERCRED) */
    struct xucred peercred;
    socklen_t   so_len = sizeof(peercred);
 
    if (getsockopt(sock, 0, LOCAL_PEERCRED, &peercred, &so_len) != 0 ||
        so_len != sizeof(peercred) ||
        peercred.cr_version != XUCRED_VERSION)
        return -1;
    *uid = peercred.cr_uid;
    *gid = peercred.cr_gid;
    return 0;
#elif defined(HAVE_GETPEERUCRED)
    /* Solaris: use getpeerucred() */
    ucred_t    *ucred;
 
    ucred = NULL;               /* must be initialized to NULL */
    if (getpeerucred(sock, &ucred) == -1)
        return -1;
 
    *uid = ucred_geteuid(ucred);
    *gid = ucred_getegid(ucred);
    ucred_free(ucred);
 
    if (*uid == (uid_t) (-1) || *gid == (gid_t) (-1))
        return -1;
    return 0;
#else
    /* No implementation available on this platform */
    errno = ENOSYS;
    return -1;
#endif
}

Referenced by auth_peer(), and PQconnectPoll().

has_drive_prefix()

bool has_drive_prefix

(

const char *

filename

)

Definition at line 88 of file path.c.

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

References skip_drive.

Referenced by process_file().

inet_aton()

int inet_aton	(	const char *	cp,
		struct in_addr *	addr
	)

Definition at line 56 of file inet_aton.c.

{
    unsigned int val;
    int         base,
                n;
    char        c;
    u_int       parts[4];
    u_int      *pp = parts;
 
    for (;;)
    {
        /*
         * Collect number up to ``.''. Values are specified as for C: 0x=hex,
         * 0=octal, other=decimal.
         */
        val = 0;
        base = 10;
        if (*cp == '0')
        {
            if (*++cp == 'x' || *cp == 'X')
                base = 16, cp++;
            else
                base = 8;
        }
        while ((c = *cp) != '\0')
        {
            if (isdigit((unsigned char) c))
            {
                val = (val * base) + (c - '0');
                cp++;
                continue;
            }
            if (base == 16 && isxdigit((unsigned char) c))
            {
                val = (val << 4) +
                    (c + 10 - (islower((unsigned char) c) ? 'a' : 'A'));
                cp++;
                continue;
            }
            break;
        }
        if (*cp == '.')
        {
            /*
             * Internet format: a.b.c.d a.b.c   (with c treated as 16-bits)
             * a.b     (with b treated as 24 bits)
             */
            if (pp >= parts + 3 || val > 0xff)
                return 0;
            *pp++ = val, cp++;
        }
        else
            break;
    }
 
    /*
     * Check for trailing junk.
     */
    while (*cp)
        if (!isspace((unsigned char) *cp++))
            return 0;
 
    /*
     * Concoct the address according to the number of parts specified.
     */
    n = pp - parts + 1;
    switch (n)
    {
 
        case 1:                 /* a -- 32 bits */
            break;
 
        case 2:                 /* a.b -- 8.24 bits */
            if (val > 0xffffff)
                return 0;
            val |= parts[0] << 24;
            break;
 
        case 3:                 /* a.b.c -- 8.8.16 bits */
            if (val > 0xffff)
                return 0;
            val |= (parts[0] << 24) | (parts[1] << 16);
            break;
 
        case 4:                 /* a.b.c.d -- 8.8.8.8 bits */
            if (val > 0xff)
                return 0;
            val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
            break;
    }
    if (addr)
        addr->s_addr = pg_hton32(val);
    return 1;
}

References pg_hton32, and val.

Referenced by getaddrinfo(), is_ip_address(), and pq_verify_peer_name_matches_certificate_ip().

join_path_components()

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

Definition at line 219 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 find_my_exec(), main(), make_relative_path(), process_file(), resolve_symlinks(), and tokenize_inc_file().

last_dir_separator()

char* last_dir_separator

(

const char *

filename

)

Definition at line 139 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(), resolve_symlinks(), sendDir(), sendFile(), setup(), and setup_bin_paths().

link()

int link	(	const char *	src,
		const char *	dst
	)

Referenced by check_hard_link(), durable_rename_excl(), and linkFile().

make_absolute_path()

char* make_absolute_path

(

const char *

path

)

Definition at line 729 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: %s\n"),
                        strerror(errno));
                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, sprintf, and strerror.

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

make_native_path()

void make_native_path

(

char *

path

)

Definition at line 167 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().

mkdtemp()

char* mkdtemp

(

char *

path

)

Definition at line 286 of file mkdtemp.c.

{
    _DIAGASSERT(path != NULL);
 
    return GETTEMP(path, NULL, 1) ? path : NULL;
}

References _DIAGASSERT, and GETTEMP().

path_contains_parent_reference()

bool path_contains_parent_reference

(

const char *

path

)

Definition at line 499 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 559 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 526 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().

pclose_check()

int pclose_check

(

FILE *

stream

)

Definition at line 408 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().

pg_ascii_tolower()

unsigned char pg_ascii_tolower

(

unsigned char

ch

)

Definition at line 146 of file pgstrcasecmp.c.

{
    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    return ch;
}

Referenced by asc_initcap(), asc_tolower(), pg_wc_tolower(), SB_lower_char(), and seq_search_ascii().

pg_ascii_toupper()

unsigned char pg_ascii_toupper

(

unsigned char

ch

)

Definition at line 135 of file pgstrcasecmp.c.

{
    if (ch >= 'a' && ch <= 'z')
        ch += 'A' - 'a';
    return ch;
}

Referenced by asc_initcap(), asc_toupper(), filter_list_to_array(), and pg_wc_toupper().

pg_check_dir()

int pg_check_dir

(

const char *

dir

)

Definition at line 33 of file pgcheckdir.c.

{
    int         result = 1;
    DIR        *chkdir;
    struct dirent *file;
    bool        dot_found = false;
    bool        mount_found = false;
    int         readdir_errno;
 
    chkdir = opendir(dir);
    if (chkdir == NULL)
        return (errno == ENOENT) ? 0 : -1;
 
    while (errno = 0, (file = readdir(chkdir)) != NULL)
    {
        if (strcmp(".", file->d_name) == 0 ||
            strcmp("..", file->d_name) == 0)
        {
            /* skip this and parent directory */
            continue;
        }
#ifndef WIN32
        /* file starts with "." */
        else if (file->d_name[0] == '.')
        {
            dot_found = true;
        }
        /* lost+found directory */
        else if (strcmp("lost+found", file->d_name) == 0)
        {
            mount_found = true;
        }
#endif
        else
        {
            result = 4;         /* not empty */
            break;
        }
    }
 
    if (errno)
        result = -1;            /* some kind of I/O error? */
 
    /* Close chkdir and avoid overwriting the readdir errno on success */
    readdir_errno = errno;
    if (closedir(chkdir))
        result = -1;            /* error executing closedir */
    else
        errno = readdir_errno;
 
    /* We report on mount point if we find a lost+found directory */
    if (result == 1 && mount_found)
        result = 3;
 
    /* We report on dot-files if we _only_ find dot files */
    if (result == 1 && dot_found)
        result = 2;
 
    return result;
}

References closedir(), dirent::d_name, opendir(), and readdir().

Referenced by bbsink_server_new(), cleanup_output_dirs(), create_data_directory(), create_xlog_or_symlink(), main(), and verify_dir_is_empty_or_create().

pg_fprintf()

int pg_fprintf	(	FILE *	stream,
		const char *	fmt,
			...
	)

pg_get_encoding_from_locale()

int pg_get_encoding_from_locale	(	const char *	ctype,
		bool	write_message
	)

Definition at line 451 of file chklocale.c.

{
    return PG_SQL_ASCII;
}

Referenced by cache_locale_time(), check_encoding_locale_matches(), check_locale_encoding(), connectOptions2(), main(), pg_import_system_collations(), PGLC_localeconv(), PQsetClientEncoding(), and setup_locale_encoding().

pg_get_user_home_dir()

bool pg_get_user_home_dir	(	uid_t	user_id,
		char *	buffer,
		size_t	buflen
	)

Definition at line 121 of file thread.c.

{
    char        pwdbuf[BUFSIZ];
    struct passwd pwdstr;
    struct passwd *pw = NULL;
    int         pwerr;
 
    pwerr = pqGetpwuid(user_id, &pwdstr, pwdbuf, sizeof(pwdbuf), &pw);
    if (pw != NULL)
    {
        strlcpy(buffer, pw->pw_dir, buflen);
        return true;
    }
    if (pwerr != 0)
        snprintf(buffer, buflen,
                 _("could not look up local user ID %d: %s"),
                 (int) user_id,
                 strerror_r(pwerr, pwdbuf, sizeof(pwdbuf)));
    else
        snprintf(buffer, buflen,
                 _("local user with ID %d does not exist"),
                 (int) user_id);
    return false;
}

References _, pqGetpwuid(), snprintf, strerror_r, and strlcpy().

Referenced by get_home_path(), and pqGetHomeDirectory().

pg_get_user_name()

bool pg_get_user_name	(	uid_t	user_id,
		char *	buffer,
		size_t	buflen
	)

Definition at line 85 of file thread.c.

{
    char        pwdbuf[BUFSIZ];
    struct passwd pwdstr;
    struct passwd *pw = NULL;
    int         pwerr;
 
    pwerr = pqGetpwuid(user_id, &pwdstr, pwdbuf, sizeof(pwdbuf), &pw);
    if (pw != NULL)
    {
        strlcpy(buffer, pw->pw_name, buflen);
        return true;
    }
    if (pwerr != 0)
        snprintf(buffer, buflen,
                 _("could not look up local user ID %d: %s"),
                 (int) user_id,
                 strerror_r(pwerr, pwdbuf, sizeof(pwdbuf)));
    else
        snprintf(buffer, buflen,
                 _("local user with ID %d does not exist"),
                 (int) user_id);
    return false;
}

References _, pqGetpwuid(), snprintf, strerror_r, and strlcpy().

Referenced by pg_fe_getusername().

pg_inet_net_ntop()

char* pg_inet_net_ntop	(	int	af,
		const void *	src,
		int	bits,
		char *	dst,
		size_t	size
	)

Definition at line 77 of file inet_net_ntop.c.

{
    /*
     * We need to cover both the address family constants used by the PG inet
     * type (PGSQL_AF_INET and PGSQL_AF_INET6) and those used by the system
     * libraries (AF_INET and AF_INET6).  We can safely assume PGSQL_AF_INET
     * == AF_INET, but the INET6 constants are very likely to be different. If
     * AF_INET6 isn't defined, silently ignore it.
     */
    switch (af)
    {
        case PGSQL_AF_INET:
            return (inet_net_ntop_ipv4(src, bits, dst, size));
        case PGSQL_AF_INET6:
#if defined(AF_INET6) && AF_INET6 != PGSQL_AF_INET6
        case AF_INET6:
#endif
            return (inet_net_ntop_ipv6(src, bits, dst, size));
        default:
            errno = EAFNOSUPPORT;
            return (NULL);
    }
}

References EAFNOSUPPORT, inet_net_ntop_ipv4(), inet_net_ntop_ipv6(), PGSQL_AF_INET, and PGSQL_AF_INET6.

Referenced by getHostaddr(), getnameinfo(), inet_abbrev(), network_host(), network_out(), network_show(), and pq_verify_peer_name_matches_certificate_ip().

pg_mkdir_p()

int pg_mkdir_p	(	char *	path,
		int	omode
	)

Definition at line 57 of file pgmkdirp.c.

{
    struct stat sb;
    mode_t      numask,
                oumask;
    int         last,
                retval;
    char       *p;
 
    retval = 0;
    p = path;
 
#ifdef WIN32
    /* skip network and drive specifiers for win32 */
    if (strlen(p) >= 2)
    {
        if (p[0] == '/' && p[1] == '/')
        {
            /* network drive */
            p = strstr(p + 2, "/");
            if (p == NULL)
            {
                errno = EINVAL;
                return -1;
            }
        }
        else if (p[1] == ':' &&
                 ((p[0] >= 'a' && p[0] <= 'z') ||
                  (p[0] >= 'A' && p[0] <= 'Z')))
        {
            /* local drive */
            p += 2;
        }
    }
#endif
 
    /*
     * POSIX 1003.2: For each dir operand that does not name an existing
     * directory, effects equivalent to those caused by the following command
     * shall occur:
     *
     * mkdir -p -m $(umask -S),u+wx $(dirname dir) && mkdir [-m mode] dir
     *
     * We change the user's umask and then restore it, instead of doing
     * chmod's.  Note we assume umask() can't change errno.
     */
    oumask = umask(0);
    numask = oumask & ~(S_IWUSR | S_IXUSR);
    (void) umask(numask);
 
    if (p[0] == '/')            /* Skip leading '/'. */
        ++p;
    for (last = 0; !last; ++p)
    {
        if (p[0] == '\0')
            last = 1;
        else if (p[0] != '/')
            continue;
        *p = '\0';
        if (!last && p[1] == '\0')
            last = 1;
 
        if (last)
            (void) umask(oumask);
 
        /* check for pre-existing directory */
        if (stat(path, &sb) == 0)
        {
            if (!S_ISDIR(sb.st_mode))
            {
                if (last)
                    errno = EEXIST;
                else
                    errno = ENOTDIR;
                retval = -1;
                break;
            }
        }
        else if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0)
        {
            retval = -1;
            break;
        }
        if (!last)
            *p = '/';
    }
 
    /* ensure we restored umask */
    (void) umask(oumask);
 
    return retval;
}

References mkdir, S_IRWXG, S_IRWXO, S_IRWXU, S_ISDIR, S_IWUSR, S_IXUSR, stat::st_mode, and stat.

Referenced by create_data_directory(), create_xlog_or_symlink(), StartLogStreamer(), and verify_dir_is_empty_or_create().

pg_pread()

ssize_t pg_pread	(	int	fd,
		void *	buf,
		size_t	nbyte,
		off_t	offset
	)

Definition at line 27 of file pread.c.

{
#ifdef WIN32
    OVERLAPPED  overlapped = {0};
    HANDLE      handle;
    DWORD       result;
 
    handle = (HANDLE) _get_osfhandle(fd);
    if (handle == INVALID_HANDLE_VALUE)
    {
        errno = EBADF;
        return -1;
    }
 
    overlapped.Offset = offset;
    if (!ReadFile(handle, buf, size, &result, &overlapped))
    {
        if (GetLastError() == ERROR_HANDLE_EOF)
            return 0;
 
        _dosmaperr(GetLastError());
        return -1;
    }
 
    return result;
#else
    if (lseek(fd, offset, SEEK_SET) < 0)
        return -1;
 
    return read(fd, buf, size);
#endif
}

References _dosmaperr(), buf, fd(), and read.

Referenced by basebackup_read_file(), FileRead(), pg_preadv(), SlruPhysicalReadPage(), WALRead(), and XLogPageRead().

pg_printf()

int pg_printf	(	const char *	fmt,
			...
	)

pg_pwrite()

ssize_t pg_pwrite	(	int	fd,
		const void *	buf,
		size_t	nbyte,
		off_t	offset
	)

Definition at line 27 of file pwrite.c.

{
#ifdef WIN32
    OVERLAPPED  overlapped = {0};
    HANDLE      handle;
    DWORD       result;
 
    handle = (HANDLE) _get_osfhandle(fd);
    if (handle == INVALID_HANDLE_VALUE)
    {
        errno = EBADF;
        return -1;
    }
 
    overlapped.Offset = offset;
    if (!WriteFile(handle, buf, size, &result, &overlapped))
    {
        _dosmaperr(GetLastError());
        return -1;
    }
 
    return result;
#else
    if (lseek(fd, offset, SEEK_SET) < 0)
        return -1;
 
    return write(fd, buf, size);
#endif
}

References _dosmaperr(), buf, fd(), and write.

Referenced by AddToDataDirLockFile(), FileWrite(), heap_xlog_logical_rewrite(), pg_pwritev(), qtext_store(), SlruPhysicalWritePage(), test_non_sync(), test_open_sync(), test_sync(), XLogFileInitInternal(), XLogWalRcvWrite(), and XLogWrite().

pg_qsort()

void pg_qsort	(	void *	base,
		size_t	nel,
		size_t	elsize,
		int(*)(const void *, const void *)	cmp
	)

Referenced by apw_load_buffers(), build_distances(), build_distinct_groups(), DropRelFileNodesAllBuffers(), FlushRelationsAllBuffers(), and InitCatalogCache().

pg_qsort_strcmp()

int pg_qsort_strcmp	(	const void *	a,
		const void *	b
	)

Definition at line 19 of file qsort.c.

{
    return strcmp(*(const char *const *) a, *(const char *const *) b);
}

References a, and b.

Referenced by readstoplist(), and searchstoplist().

pg_set_block()

bool pg_set_block

(

pgsocket

sock

)

Definition at line 49 of file noblock.c.

{
#if !defined(WIN32)
    int         flags;
 
    flags = fcntl(sock, F_GETFL);
    if (flags < 0)
        return false;
    if (fcntl(sock, F_SETFL, (flags & ~O_NONBLOCK)) == -1)
        return false;
    return true;
#else
    unsigned long ioctlsocket_ret = 0;
 
    /* Returns non-0 on failure, while fcntl() returns -1 on failure */
    return (ioctlsocket(sock, FIONBIO, &ioctlsocket_ret) == 0);
#endif
}

pg_set_noblock()

bool pg_set_noblock

(

pgsocket

sock

)

Definition at line 25 of file noblock.c.

{
#if !defined(WIN32)
    int         flags;
 
    flags = fcntl(sock, F_GETFL);
    if (flags < 0)
        return false;
    if (fcntl(sock, F_SETFL, (flags | O_NONBLOCK)) == -1)
        return false;
    return true;
#else
    unsigned long ioctlsocket_ret = 1;
 
    /* Returns non-0 on failure, while fcntl() returns -1 on failure */
    return (ioctlsocket(sock, FIONBIO, &ioctlsocket_ret) == 0);
#endif
}

Referenced by pq_init(), PQconnectPoll(), and report_fork_failure_to_client().

pg_snprintf()

int pg_snprintf	(	char *	str,
		size_t	count,
		const char *	fmt,
			...
	)

pg_sprintf()

int pg_sprintf	(	char *	str,
		const char *	fmt,
			...
	)

pg_strcasecmp()

int pg_strcasecmp	(	const char *	s1,
		const char *	s2
	)

Definition at line 36 of file pgstrcasecmp.c.

{
    for (;;)
    {
        unsigned char ch1 = (unsigned char) *s1++;
        unsigned char ch2 = (unsigned char) *s2++;
 
        if (ch1 != ch2)
        {
            if (ch1 >= 'A' && ch1 <= 'Z')
                ch1 += 'a' - 'A';
            else if (IS_HIGHBIT_SET(ch1) && isupper(ch1))
                ch1 = tolower(ch1);
 
            if (ch2 >= 'A' && ch2 <= 'Z')
                ch2 += 'a' - 'A';
            else if (IS_HIGHBIT_SET(ch2) && isupper(ch2))
                ch2 = tolower(ch2);
 
            if (ch1 != ch2)
                return (int) ch1 - (int) ch2;
        }
        if (ch1 == 0)
            break;
    }
    return 0;
}

References IS_HIGHBIT_SET, s1, and s2.

Referenced by AlterType(), appendPGArray(), array_out(), ATExecSetStorage(), build_startup_packet(), check_datestyle(), check_ident_usermap(), check_log_destination(), check_usermap(), check_wal_consistency_checking(), comp_keyword_case_hook(), config_enum_lookup_by_name(), convert_any_priv_string(), createdb(), defGetBoolean(), defGetCopyHeaderChoice(), defGetTypeLength(), DefineAggregate(), DefineCollation(), DefineType(), do_pset(), echo_hidden_hook(), echo_hook(), equivalent_locale(), evaluateSleep(), exec_command(), ExecVacuum(), find_matching_ts_config(), get_collation_actual_version(), get_progname(), GetCommandTagEnum(), getMetaCommand(), helpSQL(), histcontrol_hook(), hostname_match(), locate_stem_module(), lookup_prop_name(), main(), makeJsonEncoding(), makeVariableValue(), map_typename_pattern(), on_error_rollback_hook(), parse_basebackup_options(), parse_hstore(), parse_one_reloption(), parse_slash_copy(), parseArchiveFormat(), parseNameAndArgTypes(), ParseVariableBool(), pg_checksum_parse_type(), pg_fe_sendauth(), pg_find_encoding(), pg_size_bytes(), pg_stat_get_progress_info(), pgp_get_cipher_code(), pgp_get_digest_code(), pgstat_get_kind_from_str(), PGTYPEStimestamp_defmt_scan(), plperl_trigger_handler(), plpgsql_extra_checks_check_hook(), PLy_exec_trigger(), pq_verify_peer_name_matches_certificate_name(), process_backslash_command(), prsd_headline(), px_gen_salt(), px_resolve_alias(), ReadArrayStr(), RegisterCustomRmgr(), show_context_hook(), splitTzLine(), ssl_protocol_version_to_openssl(), sslVerifyProtocolRange(), sslVerifyProtocolVersion(), SyncRepGetStandbyPriority(), transformPartitionSpec(), unicode_norm_form_from_string(), validate_exec(), variable_is_guc_list_quote(), verbosity_hook(), verify_heapam(), wildcard_certificate_match(), and xmlpi().

pg_strerror()

char* pg_strerror

(

int

errnum

)

Definition at line 35 of file strerror.c.

{
    static char errorstr_buf[PG_STRERROR_R_BUFLEN];
 
    return pg_strerror_r(errnum, errorstr_buf, sizeof(errorstr_buf));
}

References pg_strerror_r(), and PG_STRERROR_R_BUFLEN.

pg_strerror_r()

char* pg_strerror_r	(	int	errnum,
		char *	buf,
		size_t	buflen
	)

Definition at line 46 of file strerror.c.

{
    char       *str;
 
    /* If it's a Windows Winsock error, that needs special handling */
#ifdef WIN32
    /* Winsock error code range, per WinError.h */
    if (errnum >= 10000 && errnum <= 11999)
        return win32_socket_strerror(errnum, buf, buflen);
#endif
 
    /* Try the platform's strerror_r(), or maybe just strerror() */
    str = gnuish_strerror_r(errnum, buf, buflen);
 
    /*
     * Some strerror()s return an empty string for out-of-range errno.  This
     * is ANSI C spec compliant, but not exactly useful.  Also, we may get
     * back strings of question marks if libc cannot transcode the message to
     * the codeset specified by LC_CTYPE.  If we get nothing useful, first try
     * get_errno_symbol(), and if that fails, print the numeric errno.
     */
    if (str == NULL || *str == '\0' || *str == '?')
        str = get_errno_symbol(errnum);
 
    if (str == NULL)
    {
        snprintf(buf, buflen, _("operating system error %d"), errnum);
        str = buf;
    }
 
    return str;
}

References _, buf, get_errno_symbol(), gnuish_strerror_r(), snprintf, and generate_unaccent_rules::str.

Referenced by pg_strerror().

pg_strfromd()

int pg_strfromd	(	char *	str,
		size_t	count,
		int	precision,
		double	value
	)

Definition at line 1289 of file snprintf.c.

{
    PrintfTarget target;
    int         signvalue = 0;
    int         vallen;
    char        fmt[8];
    char        convert[64];
 
    /* Set up the target like pg_snprintf, but require nonempty buffer */
    Assert(count > 0);
    target.bufstart = target.bufptr = str;
    target.bufend = str + count - 1;
    target.stream = NULL;
    target.nchars = 0;
    target.failed = false;
 
    /*
     * We bound precision to a reasonable range; the combination of this and
     * the knowledge that we're using "g" format without padding allows the
     * convert[] buffer to be reasonably small.
     */
    if (precision < 1)
        precision = 1;
    else if (precision > 32)
        precision = 32;
 
    /*
     * The rest is just an inlined version of the fmtfloat() logic above,
     * simplified using the knowledge that no padding is wanted.
     */
    if (isnan(value))
    {
        strcpy(convert, "NaN");
        vallen = 3;
    }
    else
    {
        static const double dzero = 0.0;
 
        if (value < 0.0 ||
            (value == 0.0 &&
             memcmp(&value, &dzero, sizeof(double)) != 0))
        {
            signvalue = '-';
            value = -value;
        }
 
        if (isinf(value))
        {
            strcpy(convert, "Infinity");
            vallen = 8;
        }
        else
        {
            fmt[0] = '%';
            fmt[1] = '.';
            fmt[2] = '*';
            fmt[3] = 'g';
            fmt[4] = '\0';
            vallen = sprintf(convert, fmt, precision, value);
            if (vallen < 0)
            {
                target.failed = true;
                goto fail;
            }
 
#ifdef WIN32
            if (vallen >= 6 &&
                convert[vallen - 5] == 'e' &&
                convert[vallen - 3] == '0')
            {
                convert[vallen - 3] = convert[vallen - 2];
                convert[vallen - 2] = convert[vallen - 1];
                vallen--;
            }
#endif
        }
    }
 
    if (signvalue)
        dopr_outch(signvalue, &target);
 
    dostr(convert, vallen, &target);
 
fail:
    *(target.bufptr) = '\0';
    return target.failed ? -1 : (target.bufptr - target.bufstart
                                 + target.nchars);
}

References Assert(), PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, convert(), dopr_outch(), dostr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, sprintf, generate_unaccent_rules::str, PrintfTarget::stream, and value.

Referenced by float4out(), and float8out_internal().

pg_strncasecmp()

int pg_strncasecmp	(	const char *	s1,
		const char *	s2,
		size_t	n
	)

Definition at line 69 of file pgstrcasecmp.c.

{
    while (n-- > 0)
    {
        unsigned char ch1 = (unsigned char) *s1++;
        unsigned char ch2 = (unsigned char) *s2++;
 
        if (ch1 != ch2)
        {
            if (ch1 >= 'A' && ch1 <= 'Z')
                ch1 += 'a' - 'A';
            else if (IS_HIGHBIT_SET(ch1) && isupper(ch1))
                ch1 = tolower(ch1);
 
            if (ch2 >= 'A' && ch2 <= 'Z')
                ch2 += 'a' - 'A';
            else if (IS_HIGHBIT_SET(ch2) && isupper(ch2))
                ch2 = tolower(ch2);
 
            if (ch1 != ch2)
                return (int) ch1 - (int) ch2;
        }
        if (ch1 == 0)
            break;
    }
    return 0;
}

References IS_HIGHBIT_SET, s1, and s2.

Referenced by check_datestyle(), check_special_value(), check_timezone(), command_no_begin(), do_pset(), equivalent_locale(), float4in(), float8in_internal_opt_error(), get_collation_actual_version(), helpSQL(), is_select_command(), MainLoop(), makeVariableValue(), map_sql_identifier_to_xml_name(), multirange_in(), numeric_in(), parse_bool_with_len(), parse_jsonb_index_flags(), parse_or_operator(), ParseTzFile(), ParseVariableBool(), range_parse(), scan_directory_ci(), set_unicode_line_style(), set_var_from_str(), and SpecialTags().

pg_strong_random()

bool pg_strong_random	(	void *	buf,
		size_t	len
	)

Definition at line 153 of file pg_strong_random.c.

{
    int         f;
    char       *p = buf;
    ssize_t     res;
 
    f = open("/dev/urandom", O_RDONLY, 0);
    if (f == -1)
        return false;
 
    while (len)
    {
        res = read(f, p, len);
        if (res <= 0)
        {
            if (errno == EINTR)
                continue;       /* interrupted by signal, just retry */
 
            close(f);
            return false;
        }
 
        p += res;
        len -= res;
    }
 
    close(f);
    return true;
}

References buf, close, EINTR, len, read, and res.

Referenced by build_client_first_message(), build_server_first_message(), CheckMD5Auth(), gen_random_uuid(), init_sess_key(), InitControlFile(), pad_eme_pkcs1_v15(), PerformRadiusTransaction(), pg_be_scram_build_secret(), pg_fe_scram_build_secret(), pg_random_bytes(), pgp_s2k_fill(), px_gen_salt(), RandomCancelKey(), set_random_seed(), and write_prefix().

pg_strong_random_init()

void pg_strong_random_init

(

void

)

Definition at line 147 of file pg_strong_random.c.

{
    /* No initialization needed */
}

Referenced by fork_process().

pg_strsignal()

const char* pg_strsignal

(

int

signum

)

Definition at line 42 of file pgstrsignal.c.

{
    const char *result;
 
    /*
     * If we have strsignal(3), use that --- but check its result for NULL.
     */
#ifdef HAVE_STRSIGNAL
    result = strsignal(signum);
    if (result == NULL)
        result = "unrecognized signal";
#else
 
    /*
     * We used to have code here to try to use sys_siglist[] if available.
     * However, it seems that all platforms with sys_siglist[] have also had
     * strsignal() for many years now, so that was just a waste of code.
     */
    result = "(signal names not available on this platform)";
#endif
 
    return result;
}

Referenced by log_child_failure(), LogChildExit(), shell_archive_file(), and wait_result_to_str().

pg_tolower()

unsigned char pg_tolower

(

unsigned char

ch

)

Definition at line 122 of file pgstrcasecmp.c.

{
    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    else if (IS_HIGHBIT_SET(ch) && isupper(ch))
        ch = tolower(ch);
    return ch;
}

References IS_HIGHBIT_SET.

Referenced by dir_strcmp(), ParseDateTime(), patternToSQLRegex(), PGTYPESdate_defmt_asc(), PQfnumber(), SB_lower_char(), str_initcap(), str_tolower(), and validateTzEntry().

pg_toupper()

unsigned char pg_toupper

(

unsigned char

ch

)

Definition at line 105 of file pgstrcasecmp.c.

{
    if (ch >= 'a' && ch <= 'z')
        ch += 'A' - 'a';
    else if (IS_HIGHBIT_SET(ch) && islower(ch))
        ch = toupper(ch);
    return ch;
}

References IS_HIGHBIT_SET.

Referenced by cash_words(), DetermineTimeZoneAbbrevOffsetInternal(), pg_timezone_abbrevs(), pg_tzset(), str_initcap(), and str_toupper().

pg_usleep()

void pg_usleep

(

long

microsec

)

Definition at line 53 of file signal.c.

{
    if (unlikely(pgwin32_signal_event == NULL))
    {
        /*
         * If we're reached by pgwin32_open_handle() early in startup before
         * the signal event is set up, just fall back to a regular
         * non-interruptible sleep.
         */
        SleepEx((microsec < 500 ? 1 : (microsec + 500) / 1000), FALSE);
        return;
    }
 
    if (WaitForSingleObject(pgwin32_signal_event,
                            (microsec < 500 ? 1 : (microsec + 500) / 1000))
        == WAIT_OBJECT_0)
    {
        pgwin32_dispatch_queued_signals();
        errno = EINTR;
        return;
    }
}

References EINTR, pgwin32_dispatch_queued_signals(), pgwin32_signal_event, select, and unlikely.

Referenced by _bt_pendingfsm_finalize(), auth_delay_checks(), AutoVacLauncherMain(), AutoVacWorkerMain(), BackendInitialize(), BackgroundWriterMain(), CheckpointerMain(), ConditionalXactLockTableWait(), CountOtherDBBackends(), CreateCheckPoint(), do_watch(), exec_prog(), FileRead(), FileWrite(), GetMultiXactIdMembers(), InitPostgres(), main(), perform_spin_delay(), pgarch_ArchiverCopyLoop(), pgwin32_recv(), read_local_xlog_page_guts(), regression_main(), RequestCheckpoint(), ResolveRecoveryConflictWithDatabase(), ResolveRecoveryConflictWithVirtualXIDs(), ServerLoop(), StartBackgroundWorker(), StartupXLOG(), StreamConnection(), threadRun(), wait_for_postmaster_promote(), wait_for_postmaster_start(), wait_for_postmaster_stop(), wait_pid(), WaitExceedsMaxStandbyDelay(), WALDumpOpenSegment(), WalSndWaitStopping(), WalWriterMain(), XactLockTableWait(), and XLogFlush().

pg_vfprintf()

int int pg_vfprintf	(	FILE *	stream,
		const char *	fmt,
		va_list	args
	)

Definition at line 242 of file snprintf.c.

{
    PrintfTarget target;
    char        buffer[1024];   /* size is arbitrary */
 
    if (stream == NULL)
    {
        errno = EINVAL;
        return -1;
    }
    target.bufstart = target.bufptr = buffer;
    target.bufend = buffer + sizeof(buffer);    /* use the whole buffer */
    target.stream = stream;
    target.nchars = 0;
    target.failed = false;
    dopr(&target, fmt, args);
    /* dump any remaining buffer contents */
    flushbuffer(&target);
    return target.failed ? -1 : target.nchars;
}

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, flushbuffer(), fmt, PrintfTarget::nchars, and PrintfTarget::stream.

Referenced by pg_fprintf(), pg_printf(), and pg_vprintf().

pg_vprintf()

int int pg_vprintf	(	const char *	fmt,
		va_list	args
	)

Definition at line 276 of file snprintf.c.

{
    return pg_vfprintf(stdout, fmt, args);
}

References generate_unaccent_rules::args, fmt, pg_vfprintf(), and generate_unaccent_rules::stdout.

pg_vsnprintf()

int pg_vsnprintf	(	char *	str,
		size_t	count,
		const char *	fmt,
		va_list	args
	)

Definition at line 174 of file snprintf.c.

{
    PrintfTarget target;
    char        onebyte[1];
 
    /*
     * C99 allows the case str == NULL when count == 0.  Rather than
     * special-casing this situation further down, we substitute a one-byte
     * local buffer.  Callers cannot tell, since the function result doesn't
     * depend on count.
     */
    if (count == 0)
    {
        str = onebyte;
        count = 1;
    }
    target.bufstart = target.bufptr = str;
    target.bufend = str + count - 1;
    target.stream = NULL;
    target.nchars = 0;
    target.failed = false;
    dopr(&target, fmt, args);
    *(target.bufptr) = '\0';
    return target.failed ? -1 : (target.bufptr - target.bufstart
                                 + target.nchars);
}

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, generate_unaccent_rules::str, and PrintfTarget::stream.

Referenced by pg_snprintf().

pg_vsprintf()

int int pg_vsprintf	(	char *	str,
		const char *	fmt,
		va_list	args
	)

Definition at line 214 of file snprintf.c.

{
    PrintfTarget target;
 
    target.bufstart = target.bufptr = str;
    target.bufend = NULL;
    target.stream = NULL;
    target.nchars = 0;          /* not really used in this case */
    target.failed = false;
    dopr(&target, fmt, args);
    *(target.bufptr) = '\0';
    return target.failed ? -1 : (target.bufptr - target.bufstart
                                 + target.nchars);
}

References generate_unaccent_rules::args, PrintfTarget::bufend, PrintfTarget::bufptr, PrintfTarget::bufstart, dopr(), PrintfTarget::failed, fmt, PrintfTarget::nchars, generate_unaccent_rules::str, and PrintfTarget::stream.

Referenced by pg_sprintf().

pgfnames()

char** pgfnames

(

const char *

path

)

Definition at line 37 of file pgfnames.c.

{
    DIR        *dir;
    struct dirent *file;
    char      **filenames;
    int         numnames = 0;
    int         fnsize = 200;   /* enough for many small dbs */
 
    dir = opendir(path);
    if (dir == NULL)
    {
        pg_log_warning("could not open directory \"%s\": %m", path);
        return NULL;
    }
 
    filenames = (char **) palloc(fnsize * sizeof(char *));
 
    while (errno = 0, (file = readdir(dir)) != NULL)
    {
        if (strcmp(file->d_name, ".") != 0 && strcmp(file->d_name, "..") != 0)
        {
            if (numnames + 1 >= fnsize)
            {
                fnsize *= 2;
                filenames = (char **) repalloc(filenames,
                                               fnsize * sizeof(char *));
            }
            filenames[numnames++] = pstrdup(file->d_name);
        }
    }
 
    if (errno)
        pg_log_warning("could not read directory \"%s\": %m", path);
 
    filenames[numnames] = NULL;
 
    if (closedir(dir))
        pg_log_warning("could not close directory \"%s\": %m", path);
 
    return filenames;
}

References closedir(), dirent::d_name, opendir(), palloc(), pg_log_warning, pstrdup(), readdir(), and repalloc().

Referenced by rmtree(), and scan_available_timezones().

pgfnames_cleanup()

void pgfnames_cleanup

(

char **

filenames

)

Definition at line 86 of file pgfnames.c.

{
    char      **fn;
 
    for (fn = filenames; *fn; fn++)
        pfree(*fn);
 
    pfree(filenames);
}

References fn(), and pfree().

Referenced by rmtree(), and scan_available_timezones().

pipe_read_line()

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

Definition at line 371 of file exec.c.

{
    FILE       *pgver;
 
    /* flush output buffers in case popen does not... */
    fflush(stdout);
    fflush(stderr);
 
    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, pclose_check(), and generate_unaccent_rules::stdout.

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

pqsignal()

pqsigfunc pqsignal	(	int	signo,
		pqsigfunc	func
	)

Definition at line 180 of file signal.c.

{
    pqsigfunc   prevfunc;
 
    if (signum >= PG_SIGNAL_COUNT || signum < 0)
        return SIG_ERR;
    prevfunc = pg_signal_array[signum];
    pg_signal_array[signum] = handler;
    return prevfunc;
}

References pg_signal_array, PG_SIGNAL_COUNT, SIG_ERR, SIGALRM, and SIGCHLD.

Referenced by ApplyLauncherMain(), ApplyWorkerMain(), autoprewarm_database_main(), autoprewarm_main(), AutoVacLauncherMain(), AutoVacWorkerMain(), BackendInitialize(), BackgroundWriterMain(), bootstrap_signals(), CheckpointerMain(), disable_sigpipe_trap(), do_start(), InitializeLatchSupport(), InitializeTimeouts(), InitPostmasterChild(), main(), OpenPipeStream(), ParallelBackupStart(), ParallelWorkerMain(), pg_crc32c_armv8_available(), PgArchiverMain(), plperl_init_interp(), PostgresMain(), PostmasterDeathSignalInit(), PQprint(), pqsignal_pm(), restore_sigpipe_trap(), setalarm(), setup_cancel_handler(), setup_signals(), ShutdownLatchSupport(), sigTermHandler(), StartBackgroundWorker(), StartupProcessMain(), SysLoggerMain(), test_shm_mq_main(), trap_sigint_during_startup(), trapsig(), WalReceiverMain(), WalSndSignals(), and WalWriterMain().

qsort_arg()

void qsort_arg	(	void *	base,
		size_t	nel,
		size_t	elsize,
		qsort_arg_comparator	cmp,
		void *	arg
	)

Referenced by _bt_sort_array_elements(), build_column_frequencies(), build_sorted_items(), compute_range_stats(), compute_scalar_stats(), create_list_bounds(), create_range_bounds(), gbt_num_picksplit(), gbt_var_picksplit(), ginExtractEntries(), isort(), mcelem_array_selec(), multirange_canonicalize(), ndistinct_for_combination(), range_deduplicate_values(), range_gist_double_sorting_split(), range_gist_single_sorting_split(), reduce_expanded_ranges(), sort_expanded_ranges(), SortAndUniqItems(), spg_range_quad_picksplit(), startScanKey(), statext_mcv_serialize(), tbm_prepare_shared_iterate(), tsvectorrecv(), uniqueentry(), and uniqueifyJsonbObject().

rmtree()

bool rmtree	(	const char *	path,
		bool	rmtopdir
	)

Definition at line 42 of file rmtree.c.

{
    bool        result = true;
    char        pathbuf[MAXPGPATH];
    char      **filenames;
    char      **filename;
    struct stat statbuf;
 
    /*
     * we copy all the names out of the directory before we start modifying
     * it.
     */
    filenames = pgfnames(path);
 
    if (filenames == NULL)
        return false;
 
    /* now we have the names we can start removing things */
    for (filename = filenames; *filename; filename++)
    {
        snprintf(pathbuf, MAXPGPATH, "%s/%s", path, *filename);
 
        /*
         * It's ok if the file is not there anymore; we were just about to
         * delete it anyway.
         *
         * This is not an academic possibility. One scenario where this
         * happens is when bgwriter has a pending unlink request for a file in
         * a database that's being dropped. In dropdb(), we call
         * ForgetDatabaseSyncRequests() to flush out any such pending unlink
         * requests, but because that's asynchronous, it's not guaranteed that
         * the bgwriter receives the message in time.
         */
        if (lstat(pathbuf, &statbuf) != 0)
        {
            if (errno != ENOENT)
            {
                pg_log_warning("could not stat file or directory \"%s\": %m",
                               pathbuf);
                result = false;
            }
            continue;
        }
 
        if (S_ISDIR(statbuf.st_mode))
        {
            /* call ourselves recursively for a directory */
            if (!rmtree(pathbuf, true))
            {
                /* we already reported the error */
                result = false;
            }
        }
        else
        {
            if (unlink(pathbuf) != 0)
            {
                if (errno != ENOENT)
                {
                    pg_log_warning("could not remove file or directory \"%s\": %m",
                                   pathbuf);
                    result = false;
                }
            }
        }
    }
 
    if (rmtopdir)
    {
        if (rmdir(path) != 0)
        {
            pg_log_warning("could not remove file or directory \"%s\": %m",
                           path);
            result = false;
        }
    }
 
    pgfnames_cleanup(filenames);
 
    return result;
}

References filename, lstat, MAXPGPATH, pg_log_warning, pgfnames(), pgfnames_cleanup(), S_ISDIR, snprintf, and stat::st_mode.

Referenced by cleanup_directories_atexit(), cleanup_output_dirs(), CreateSlotOnDisk(), dbase_redo(), movedb(), movedb_failure_callback(), regression_main(), remove_dbtablespaces(), remove_new_subdir(), ReplicationSlotDropPtr(), RestoreSlotFromDisk(), and StartupReplicationSlots().

set_pglocale_pgservice()

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

Definition at line 446 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().

setenv()

int setenv	(	const char *	name,
		const char *	value,
		int	overwrite
	)

Definition at line 20 of file setenv.c.

{
    char       *envstr;
 
    /* Error conditions, per POSIX */
    if (name == NULL || name[0] == '\0' || strchr(name, '=') != NULL ||
        value == NULL)
    {
        errno = EINVAL;
        return -1;
    }
 
    /* No work if variable exists and we're not to replace it */
    if (overwrite == 0 && getenv(name) != NULL)
        return 0;
 
    /*
     * Add or replace the value using putenv().  This will leak memory if the
     * same variable is repeatedly redefined, but there's little we can do
     * about that when sitting atop putenv().
     */
    envstr = (char *) malloc(strlen(name) + strlen(value) + 2);
    if (!envstr)                /* not much we can do if no memory */
        return -1;
 
    sprintf(envstr, "%s=%s", name, value);
 
    return putenv(envstr);
}

References malloc, name, overwrite(), putenv, sprintf, and value.

strlcat()

size_t strlcat	(	char *	dst,
		const char *	src,
		size_t	siz
	)

Definition at line 33 of file strlcat.c.

{
    char       *d = dst;
    const char *s = src;
    size_t      n = siz;
    size_t      dlen;
 
    /* Find the end of dst and adjust bytes left but don't go past end */
    while (n-- != 0 && *d != '\0')
        d++;
    dlen = d - dst;
    n = siz - dlen;
 
    if (n == 0)
        return (dlen + strlen(s));
    while (*s != '\0')
    {
        if (n != 1)
        {
            *d++ = *s;
            n--;
        }
        s++;
    }
    *d = '\0';
 
    return (dlen + (s - src));  /* count does not include NUL */
}

Referenced by _PrepParallelRestore(), CreateBackupStreamer(), CreateLockFile(), get_configdata(), and get_prompt().

strlcpy()

size_t strlcpy	(	char *	dst,
		const char *	src,
		size_t	siz
	)

Definition at line 45 of file strlcpy.c.

{
    char       *d = dst;
    const char *s = src;
    size_t      n = siz;
 
    /* Copy as many bytes as will fit */
    if (n != 0)
    {
        while (--n != 0)
        {
            if ((*d++ = *s++) == '\0')
                break;
        }
    }
 
    /* Not enough room in dst, add NUL and traverse rest of src */
    if (n == 0)
    {
        if (siz != 0)
            *d = '\0';          /* NUL-terminate dst */
        while (*s++)
            ;
    }
 
    return (s - src - 1);       /* count does not include NUL */
}

Referenced by _tarGetHeader(), abstime2tm(), BaseBackup(), bbstreamer_inject_file(), bbstreamer_tar_header(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), BootstrapModeMain(), ChooseConstraintName(), ChooseExtendedStatisticName(), ChooseExtendedStatisticNameAddition(), ChooseForeignKeyConstraintNameAddition(), ChooseIndexNameAddition(), ChooseRelationName(), CleanupPriorWALFiles(), ConvertTimeZoneAbbrevs(), create_script_for_old_cluster_deletion(), createNewConnection(), DCH_cache_getnew(), DefineRelation(), descriptor_variable(), DetermineTimeZoneAbbrevOffsetInternal(), ensureCleanShutdown(), ExecuteRecoveryCommand(), expand_tilde(), fetch_fp_info(), find_in_dynamic_libpath(), find_my_exec(), find_other_exec_or_die(), from_char_parse_int_len(), fsync_parent_path(), get_configdata(), get_control_data(), get_home_path(), get_prompt(), get_tablespace_mapping(), getRestoreCommand(), gnuish_strerror_r(), hash_create(), identify_system_timezone(), initialize_SSL(), InitPostgres(), isolation_init(), join_path_components(), KeepFileRestoredFromArchive(), logfile_getname(), logicalrep_read_begin_prepare(), logicalrep_read_commit_prepared(), logicalrep_read_prepare_common(), logicalrep_read_rollback_prepared(), main(), make_oper_cache_key(), make_relative_path(), makeUniqueTypeName(), mdsyncfiletag(), mdunlinkfiletag(), NUM_cache_getnew(), ParseAbortRecord(), parseCommandLine(), ParseCommitRecord(), ParseLongOption(), parseServiceInfo(), pg_get_user_home_dir(), pg_get_user_name(), pg_getnameinfo_all(), pg_open_tzfile(), pg_perm_setlocale(), pg_stat_get_wal_receiver(), pg_timezone_abbrevs(), pg_TZDIR(), pg_tzenumerate_next(), pgstat_bestart(), postprocess_sql_command(), PQcancel(), pqGetErrorNotice3(), pqGetHomeDirectory(), pqParseInput3(), PQrequestCancel(), process_file(), process_postgres_switches(), px_crypt_des(), recoveryStopsAfter(), RequestNamedLWLockTranche(), RequestXLogStreaming(), resolve_symlinks(), results_differ(), rot13_passphrase(), scan_available_timezones(), scan_directory(), scan_directory_ci(), SerializeLibraryState(), set_ps_display(), setup_bin_paths(), shell_archive_file(), SimpleLruInit(), SSLerrmessage(), tar_close(), timestamptz_to_str(), uuid_generate_internal(), validate_exec(), WalReceiverMain(), and XLogRestorePoint().

strnlen()

size_t strnlen	(	const char *	str,
		size_t	maxlen
	)

Definition at line 26 of file strnlen.c.

{
    const char *p = str;
 
    while (maxlen-- > 0 && *p)
        p++;
    return p - str;
}

References generate_unaccent_rules::str.

Referenced by fmtstr(), pg_encoding_mblen_bounded(), pnstrdup(), and PQmblenBounded().

strtof()

float strtof	(	const char *	nptr,
		char **	endptr
	)

Definition at line 28 of file strtof.c.

{
    int         caller_errno = errno;
    double      dresult;
    float       fresult;
 
    errno = 0;
    dresult = strtod(nptr, endptr);
    fresult = (float) dresult;
 
    if (errno == 0)
    {
        /*
         * Value might be in-range for double but not float.
         */
        if (dresult != 0 && fresult == 0)
            caller_errno = ERANGE;  /* underflow */
        if (!isinf(dresult) && isinf(fresult))
            caller_errno = ERANGE;  /* overflow */
    }
    else
        caller_errno = errno;
 
    errno = caller_errno;
    return fresult;
}

Referenced by float4in().

unsetenv()

int unsetenv

(

const char *

name

)

Definition at line 20 of file unsetenv.c.

{
    char       *envstr;
 
    /* Error conditions, per POSIX */
    if (name == NULL || name[0] == '\0' || strchr(name, '=') != NULL)
    {
        errno = EINVAL;
        return -1;
    }
 
    if (getenv(name) == NULL)
        return 0;               /* no work */
 
    /*
     * The technique embodied here works if libc follows the Single Unix Spec
     * and actually uses the storage passed to putenv() to hold the environ
     * entry.  When we clobber the entry in the second step we are ensuring
     * that we zap the actual environ member.  However, there are some libc
     * implementations (notably recent BSDs) that do not obey SUS but copy the
     * presented string.  This method fails on such platforms.  Hopefully all
     * such platforms have unsetenv() and thus won't be using this hack. See:
     * http://www.greenend.org.uk/rjk/2008/putenv.html
     *
     * Note that repeatedly setting and unsetting a var using this code will
     * leak memory.
     */
 
    envstr = (char *) malloc(strlen(name) + 2);
    if (!envstr)                /* not much we can do if no memory */
        return -1;
 
    /* Override the existing setting by forcibly defining the var */
    sprintf(envstr, "%s=", name);
    if (putenv(envstr))
        return -1;
 
    /* Now we can clobber the variable definition this way: */
    strcpy(envstr, "=");
 
    /*
     * This last putenv cleans up if we have multiple zero-length names as a
     * result of unsetting multiple things.
     */
    return putenv(envstr);
}

References malloc, name, putenv, and sprintf.

validate_exec()

int validate_exec

(

const char *

path

)

Definition at line 79 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))
        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);
#else
    is_r = buf.st_mode & S_IRUSR;
    is_x = buf.st_mode & S_IXUSR;
#endif
    return is_x ? (is_r ? 0 : -2) : -1;
}

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

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

wait_result_is_any_signal()

bool wait_result_is_any_signal	(	int	exit_status,
		bool	include_command_not_found
	)

Definition at line 111 of file wait_error.c.

{
    if (WIFSIGNALED(exit_status))
        return true;
    if (WIFEXITED(exit_status) &&
        WEXITSTATUS(exit_status) > (include_command_not_found ? 125 : 128))
        return true;
    return false;
}

References WEXITSTATUS, WIFEXITED, and WIFSIGNALED.

Referenced by ExecuteRecoveryCommand(), RestoreArchivedFile(), and shell_archive_file().

wait_result_is_signal()

bool wait_result_is_signal	(	int	exit_status,
		int	signum
	)

Definition at line 92 of file wait_error.c.

{
    if (WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum)
        return true;
    if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == 128 + signum)
        return true;
    return false;
}

References WEXITSTATUS, WIFEXITED, WIFSIGNALED, and WTERMSIG.

Referenced by ClosePipeFromProgram(), and RestoreArchivedFile().

wait_result_to_str()

char* wait_result_to_str

(

int

exit_status

)

Definition at line 32 of file wait_error.c.

{
    char        str[512];
 
    if (WIFEXITED(exitstatus))
    {
        /*
         * Give more specific error message for some common exit codes that
         * have a special meaning in shells.
         */
        switch (WEXITSTATUS(exitstatus))
        {
            case 126:
                snprintf(str, sizeof(str), _("command not executable"));
                break;
 
            case 127:
                snprintf(str, sizeof(str), _("command not found"));
                break;
 
            default:
                snprintf(str, sizeof(str),
                         _("child process exited with exit code %d"),
                         WEXITSTATUS(exitstatus));
        }
    }
    else if (WIFSIGNALED(exitstatus))
    {
#if defined(WIN32)
        snprintf(str, sizeof(str),
                 _("child process was terminated by exception 0x%X"),
                 WTERMSIG(exitstatus));
#else
        snprintf(str, sizeof(str),
                 _("child process was terminated by signal %d: %s"),
                 WTERMSIG(exitstatus), pg_strsignal(WTERMSIG(exitstatus)));
#endif
    }
    else
        snprintf(str, sizeof(str),
                 _("child process exited with unrecognized status %d"),
                 exitstatus);
 
    return pstrdup(str);
}

References _, pg_strsignal(), pstrdup(), snprintf, generate_unaccent_rules::str, WEXITSTATUS, WIFEXITED, WIFSIGNALED, and WTERMSIG.

Referenced by BaseBackup(), ClosePipeFromProgram(), ClosePipeToProgram(), do_copy(), ExecuteRecoveryCommand(), pclose_check(), RestoreArchivedFile(), run_ssl_passphrase_command(), and shell_finish_command().