dumputils.h File Reference

#include "libpq-fe.h"
#include "pqexpbuffer.h"

Include dependency graph for dumputils.h:

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

Go to the source code of this file.

Macros
#define	PGDUMP_STRFTIME_FMT   "%Y-%m-%d %H:%M:%S %Z"

Functions
char *	sanitize_line (const char *str, bool want_hyphen)
bool	buildACLCommands (const char *name, const char *subname, const char *nspname, const char *type, const char *acls, const char *baseacls, const char *owner, const char *prefix, int remoteVersion, PQExpBuffer sql)
bool	buildDefaultACLCommands (const char *type, const char *nspname, const char *acls, const char *acldefault, const char *owner, int remoteVersion, PQExpBuffer sql)
void	quoteAclUserName (PQExpBuffer output, const char *input)
void	buildShSecLabelQuery (const char *catalog_name, Oid objectId, PQExpBuffer sql)
void	emitShSecLabels (PGconn *conn, PGresult *res, PQExpBuffer buffer, const char *objtype, const char *objname)
bool	variable_is_guc_list_quote (const char *name)
bool	SplitGUCList (char *rawstring, char separator, char ***namelist)
void	makeAlterConfigCommand (PGconn *conn, const char *configitem, const char *type, const char *name, const char *type2, const char *name2, PQExpBuffer buf)
void	create_or_open_dir (const char *dirname)
char *	generate_restrict_key (void)
bool	valid_restrict_key (const char *restrict_key)

Macro Definition Documentation

PGDUMP_STRFTIME_FMT

#define PGDUMP_STRFTIME_FMT   "%Y-%m-%d %H:%M:%S %Z"

Definition at line 33 of file dumputils.h.

Function Documentation

buildACLCommands()

bool buildACLCommands	(	const char *	name,
		const char *	subname,
		const char *	nspname,
		const char *	type,
		const char *	acls,
		const char *	baseacls,
		const char *	owner,
		const char *	prefix,
		int	remoteVersion,
		PQExpBuffer	sql
	)

Definition at line 104 of file dumputils.c.

{
    bool        ok = true;
    char      **aclitems = NULL;
    char      **baseitems = NULL;
    char      **grantitems = NULL;
    char      **revokeitems = NULL;
    int         naclitems = 0;
    int         nbaseitems = 0;
    int         ngrantitems = 0;
    int         nrevokeitems = 0;
    int         i;
    PQExpBuffer grantee,
                grantor,
                privs,
                privswgo;
    PQExpBuffer firstsql,
                secondsql;
 
    /*
     * If the acl was NULL (initial default state), we need do nothing.  Note
     * that this is distinguishable from all-privileges-revoked, which will
     * look like an empty array ("{}").
     */
    if (acls == NULL || *acls == '\0')
        return true;            /* object has default permissions */
 
    /* treat empty-string owner same as NULL */
    if (owner && *owner == '\0')
        owner = NULL;
 
    /* Parse the acls array */
    if (!parsePGArray(acls, &aclitems, &naclitems))
    {
        free(aclitems);
        return false;
    }
 
    /* Parse the baseacls too */
    if (!parsePGArray(baseacls, &baseitems, &nbaseitems))
    {
        free(aclitems);
        free(baseitems);
        return false;
    }
 
    /*
     * Compare the actual ACL with the base ACL, extracting the privileges
     * that need to be granted (i.e., are in the actual ACL but not the base
     * ACL) and the ones that need to be revoked (the reverse).  We use plain
     * string comparisons to check for matches.  In principle that could be
     * fooled by extraneous issues such as whitespace, but since all these
     * strings are the work of aclitemout(), it should be OK in practice.
     * Besides, a false mismatch will just cause the output to be a little
     * more verbose than it really needed to be.
     */
    grantitems = (char **) pg_malloc(naclitems * sizeof(char *));
    for (i = 0; i < naclitems; i++)
    {
        bool        found = false;
 
        for (int j = 0; j < nbaseitems; j++)
        {
            if (strcmp(aclitems[i], baseitems[j]) == 0)
            {
                found = true;
                break;
            }
        }
        if (!found)
            grantitems[ngrantitems++] = aclitems[i];
    }
    revokeitems = (char **) pg_malloc(nbaseitems * sizeof(char *));
    for (i = 0; i < nbaseitems; i++)
    {
        bool        found = false;
 
        for (int j = 0; j < naclitems; j++)
        {
            if (strcmp(baseitems[i], aclitems[j]) == 0)
            {
                found = true;
                break;
            }
        }
        if (!found)
            revokeitems[nrevokeitems++] = baseitems[i];
    }
 
    /* Prepare working buffers */
    grantee = createPQExpBuffer();
    grantor = createPQExpBuffer();
    privs = createPQExpBuffer();
    privswgo = createPQExpBuffer();
 
    /*
     * At the end, these two will be pasted together to form the result.
     */
    firstsql = createPQExpBuffer();
    secondsql = createPQExpBuffer();
 
    /*
     * Build REVOKE statements for ACLs listed in revokeitems[].
     */
    for (i = 0; i < nrevokeitems; i++)
    {
        if (!parseAclItem(revokeitems[i],
                          type, name, subname, remoteVersion,
                          grantee, grantor, privs, NULL))
        {
            ok = false;
            break;
        }
 
        if (privs->len > 0)
        {
            appendPQExpBuffer(firstsql, "%sREVOKE %s ON %s ",
                              prefix, privs->data, type);
            if (nspname && *nspname)
                appendPQExpBuffer(firstsql, "%s.", fmtId(nspname));
            if (name && *name)
                appendPQExpBuffer(firstsql, "%s ", name);
            appendPQExpBufferStr(firstsql, "FROM ");
            if (grantee->len == 0)
                appendPQExpBufferStr(firstsql, "PUBLIC;\n");
            else
                appendPQExpBuffer(firstsql, "%s;\n",
                                  fmtId(grantee->data));
        }
    }
 
    /*
     * At this point we have issued REVOKE statements for all initial and
     * default privileges that are no longer present on the object, so we are
     * almost ready to GRANT the privileges listed in grantitems[].
     *
     * We still need some hacking though to cover the case where new default
     * public privileges are added in new versions: the REVOKE ALL will revoke
     * them, leading to behavior different from what the old version had,
     * which is generally not what's wanted.  So add back default privs if the
     * source database is too old to have had that particular priv.  (As of
     * right now, no such cases exist in supported versions.)
     */
 
    /*
     * Scan individual ACL items to be granted.
     *
     * The order in which privileges appear in the ACL string (the order they
     * have been GRANT'd in, which the backend maintains) must be preserved to
     * ensure that GRANTs WITH GRANT OPTION and subsequent GRANTs based on
     * those are dumped in the correct order.  However, some old server
     * versions will show grants to PUBLIC before the owner's own grants; for
     * consistency's sake, force the owner's grants to be output first.
     */
    for (i = 0; i < ngrantitems; i++)
    {
        if (parseAclItem(grantitems[i], type, name, subname, remoteVersion,
                         grantee, grantor, privs, privswgo))
        {
            /*
             * If the grantor isn't the owner, we'll need to use SET SESSION
             * AUTHORIZATION to become the grantor.  Issue the SET/RESET only
             * if there's something useful to do.
             */
            if (privs->len > 0 || privswgo->len > 0)
            {
                PQExpBuffer thissql;
 
                /* Set owner as grantor if that's not explicit in the ACL */
                if (grantor->len == 0 && owner)
                    printfPQExpBuffer(grantor, "%s", owner);
 
                /* Make sure owner's own grants are output before others */
                if (owner &&
                    strcmp(grantee->data, owner) == 0 &&
                    strcmp(grantor->data, owner) == 0)
                    thissql = firstsql;
                else
                    thissql = secondsql;
 
                if (grantor->len > 0
                    && (!owner || strcmp(owner, grantor->data) != 0))
                    appendPQExpBuffer(thissql, "SET SESSION AUTHORIZATION %s;\n",
                                      fmtId(grantor->data));
 
                if (privs->len > 0)
                {
                    appendPQExpBuffer(thissql, "%sGRANT %s ON %s ",
                                      prefix, privs->data, type);
                    if (nspname && *nspname)
                        appendPQExpBuffer(thissql, "%s.", fmtId(nspname));
                    if (name && *name)
                        appendPQExpBuffer(thissql, "%s ", name);
                    appendPQExpBufferStr(thissql, "TO ");
                    if (grantee->len == 0)
                        appendPQExpBufferStr(thissql, "PUBLIC;\n");
                    else
                        appendPQExpBuffer(thissql, "%s;\n", fmtId(grantee->data));
                }
                if (privswgo->len > 0)
                {
                    appendPQExpBuffer(thissql, "%sGRANT %s ON %s ",
                                      prefix, privswgo->data, type);
                    if (nspname && *nspname)
                        appendPQExpBuffer(thissql, "%s.", fmtId(nspname));
                    if (name && *name)
                        appendPQExpBuffer(thissql, "%s ", name);
                    appendPQExpBufferStr(thissql, "TO ");
                    if (grantee->len == 0)
                        appendPQExpBufferStr(thissql, "PUBLIC");
                    else
                        appendPQExpBufferStr(thissql, fmtId(grantee->data));
                    appendPQExpBufferStr(thissql, " WITH GRANT OPTION;\n");
                }
 
                if (grantor->len > 0
                    && (!owner || strcmp(owner, grantor->data) != 0))
                    appendPQExpBufferStr(thissql, "RESET SESSION AUTHORIZATION;\n");
            }
        }
        else
        {
            /* parseAclItem failed, give up */
            ok = false;
            break;
        }
    }
 
    destroyPQExpBuffer(grantee);
    destroyPQExpBuffer(grantor);
    destroyPQExpBuffer(privs);
    destroyPQExpBuffer(privswgo);
 
    appendPQExpBuffer(sql, "%s%s", firstsql->data, secondsql->data);
    destroyPQExpBuffer(firstsql);
    destroyPQExpBuffer(secondsql);
 
    free(aclitems);
    free(baseitems);
    free(grantitems);
    free(revokeitems);
 
    return ok;
}

References appendPQExpBuffer(), appendPQExpBufferStr(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), free, i, j, PQExpBufferData::len, name, parseAclItem(), parsePGArray(), pg_malloc(), printfPQExpBuffer(), subname, and type.

Referenced by buildDefaultACLCommands(), dumpACL(), dumpRoleGUCPrivs(), and dumpTablespaces().

buildDefaultACLCommands()

bool buildDefaultACLCommands	(	const char *	type,
		const char *	nspname,
		const char *	acls,
		const char *	acldefault,
		const char *	owner,
		int	remoteVersion,
		PQExpBuffer	sql
	)

Definition at line 366 of file dumputils.c.

{
    PQExpBuffer prefix;
 
    prefix = createPQExpBuffer();
 
    /*
     * We incorporate the target role directly into the command, rather than
     * playing around with SET ROLE or anything like that.  This is so that a
     * permissions error leads to nothing happening, rather than changing
     * default privileges for the wrong user.
     */
    appendPQExpBuffer(prefix, "ALTER DEFAULT PRIVILEGES FOR ROLE %s ",
                      fmtId(owner));
    if (nspname)
        appendPQExpBuffer(prefix, "IN SCHEMA %s ", fmtId(nspname));
 
    /*
     * There's no such thing as initprivs for a default ACL, so the base ACL
     * is always just the object-type-specific default.
     */
    if (!buildACLCommands("", NULL, NULL, type,
                          acls, acldefault, owner,
                          prefix->data, remoteVersion, sql))
    {
        destroyPQExpBuffer(prefix);
        return false;
    }
 
    destroyPQExpBuffer(prefix);
 
    return true;
}

References acldefault(), appendPQExpBuffer(), buildACLCommands(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), and type.

Referenced by dumpDefaultACL().

buildShSecLabelQuery()

void buildShSecLabelQuery	(	const char *	catalog_name,
		Oid	objectId,
		PQExpBuffer	sql
	)

Definition at line 678 of file dumputils.c.

{
    appendPQExpBuffer(sql,
                      "SELECT provider, label FROM pg_catalog.pg_shseclabel "
                      "WHERE classoid = 'pg_catalog.%s'::pg_catalog.regclass "
                      "AND objoid = '%u'", catalog_name, objectId);
}

References appendPQExpBuffer().

Referenced by buildShSecLabels(), and dumpDatabase().

create_or_open_dir()

void create_or_open_dir

(

const char *

dirname

)

Definition at line 935 of file dumputils.c.

{
    int         ret;
 
    switch ((ret = pg_check_dir(dirname)))
    {
        case -1:
            /* opendir failed but not with ENOENT */
            pg_fatal("could not open directory \"%s\": %m", dirname);
            break;
        case 0:
            /* directory does not exist */
            if (mkdir(dirname, pg_dir_create_mode) < 0)
                pg_fatal("could not create directory \"%s\": %m", dirname);
            break;
        case 1:
            /* exists and is empty, fix perms */
            if (chmod(dirname, pg_dir_create_mode) != 0)
                pg_fatal("could not change permissions of directory \"%s\": %m",
                         dirname);
            break;
        default:
            /* exists and is not empty */
            pg_fatal("directory \"%s\" is not empty", dirname);
    }
}

References mkdir, pg_check_dir(), pg_dir_create_mode, and pg_fatal.

Referenced by InitArchiveFmt_Directory().

emitShSecLabels()

void emitShSecLabels	(	PGconn *	conn,
		PGresult *	res,
		PQExpBuffer	buffer,
		const char *	objtype,
		const char *	objname
	)

Definition at line 696 of file dumputils.c.

{
    int         i;
 
    for (i = 0; i < PQntuples(res); i++)
    {
        char       *provider = PQgetvalue(res, i, 0);
        char       *label = PQgetvalue(res, i, 1);
 
        /* must use fmtId result before calling it again */
        appendPQExpBuffer(buffer,
                          "SECURITY LABEL FOR %s ON %s",
                          fmtId(provider), objtype);
        appendPQExpBuffer(buffer,
                          " %s IS ",
                          fmtId(objname));
        appendStringLiteralConn(buffer, label, conn);
        appendPQExpBufferStr(buffer, ";\n");
    }
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), conn, fmtId(), i, label, PQgetvalue, and PQntuples.

Referenced by buildShSecLabels(), and dumpDatabase().

generate_restrict_key()

char * generate_restrict_key

(

void

)

Definition at line 968 of file dumputils.c.

{
    uint8       buf[64];
    char       *ret = palloc(sizeof(buf));
 
    if (!pg_strong_random(buf, sizeof(buf)))
        return NULL;
 
    for (int i = 0; i < sizeof(buf) - 1; i++)
    {
        uint8       idx = buf[i] % strlen(restrict_chars);
 
        ret[i] = restrict_chars[idx];
    }
    ret[sizeof(buf) - 1] = '\0';
 
    return ret;
}

References buf, i, idx(), palloc(), pg_strong_random(), and restrict_chars.

Referenced by main().

makeAlterConfigCommand()

void makeAlterConfigCommand	(	PGconn *	conn,
		const char *	configitem,
		const char *	type,
		const char *	name,
		const char *	type2,
		const char *	name2,
		PQExpBuffer	buf
	)

Definition at line 864 of file dumputils.c.

{
    char       *mine;
    char       *pos;
 
    /* Parse the configitem.  If we can't find an "=", silently do nothing. */
    mine = pg_strdup(configitem);
    pos = strchr(mine, '=');
    if (pos == NULL)
    {
        pg_free(mine);
        return;
    }
    *pos++ = '\0';
 
    /* Build the command, with suitable quoting for everything. */
    appendPQExpBuffer(buf, "ALTER %s %s ", type, fmtId(name));
    if (type2 != NULL && name2 != NULL)
        appendPQExpBuffer(buf, "IN %s %s ", type2, fmtId(name2));
    appendPQExpBuffer(buf, "SET %s TO ", fmtId(mine));
 
    /*
     * Variables that are marked GUC_LIST_QUOTE were already fully quoted by
     * flatten_set_variable_args() before they were put into the setconfig
     * array.  However, because the quoting rules used there aren't exactly
     * like SQL's, we have to break the list value apart and then quote the
     * elements as string literals.  (The elements may be double-quoted as-is,
     * but we can't just feed them to the SQL parser; it would do the wrong
     * thing with elements that are zero-length or longer than NAMEDATALEN.)
     *
     * Variables that are not so marked should just be emitted as simple
     * string literals.  If the variable is not known to
     * variable_is_guc_list_quote(), we'll do that; this makes it unsafe to
     * use GUC_LIST_QUOTE for extension variables.
     */
    if (variable_is_guc_list_quote(mine))
    {
        char      **namelist;
        char      **nameptr;
 
        /* Parse string into list of identifiers */
        /* this shouldn't fail really */
        if (SplitGUCList(pos, ',', &namelist))
        {
            for (nameptr = namelist; *nameptr; nameptr++)
            {
                if (nameptr != namelist)
                    appendPQExpBufferStr(buf, ", ");
                appendStringLiteralConn(buf, *nameptr, conn);
            }
        }
        pg_free(namelist);
    }
    else
        appendStringLiteralConn(buf, pos, conn);
 
    appendPQExpBufferStr(buf, ";\n");
 
    pg_free(mine);
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), buf, conn, fmtId(), name, pg_free(), pg_strdup(), SplitGUCList(), type, and variable_is_guc_list_quote().

Referenced by dumpDatabaseConfig(), and dumpUserConfig().

quoteAclUserName()

void quoteAclUserName	(	PQExpBuffer	output,
		const char *	input
	)

Definition at line 585 of file dumputils.c.

{
    const char *src;
    bool        safe = true;
 
    for (src = input; *src; src++)
    {
        /* This test had better match what putid() does */
        if (!isalnum((unsigned char) *src) && *src != '_')
        {
            safe = false;
            break;
        }
    }
    if (!safe)
        appendPQExpBufferChar(output, '"');
    for (src = input; *src; src++)
    {
        /* A double quote character in a username is encoded as "" */
        if (*src == '"')
            appendPQExpBufferChar(output, '"');
        appendPQExpBufferChar(output, *src);
    }
    if (!safe)
        appendPQExpBufferChar(output, '"');
}

References appendPQExpBufferChar(), input, and output.

Referenced by getNamespaces().

sanitize_line()

char * sanitize_line	(	const char *	str,
		bool	want_hyphen
	)

Definition at line 52 of file dumputils.c.

{
    char       *result;
    char       *s;
 
    if (!str)
        return pg_strdup(want_hyphen ? "-" : "");
 
    result = pg_strdup(str);
 
    for (s = result; *s != '\0'; s++)
    {
        if (*s == '\n' || *s == '\r')
            *s = ' ';
    }
 
    return result;
}

References pg_strdup(), and str.

Referenced by _printTocEntry(), dumpDatabases(), dumpTableData(), dumpUserConfig(), and PrintTOCSummary().

SplitGUCList()

bool SplitGUCList	(	char *	rawstring,
		char	separator,
		char ***	namelist
	)

Definition at line 764 of file dumputils.c.

{
    char       *nextp = rawstring;
    bool        done = false;
    char      **nextptr;
 
    /*
     * Since we disallow empty identifiers, this is a conservative
     * overestimate of the number of pointers we could need.  Allow one for
     * list terminator.
     */
    *namelist = nextptr = (char **)
        pg_malloc((strlen(rawstring) / 2 + 2) * sizeof(char *));
    *nextptr = NULL;
 
    while (isspace((unsigned char) *nextp))
        nextp++;                /* skip leading whitespace */
 
    if (*nextp == '\0')
        return true;            /* allow empty string */
 
    /* At the top of the loop, we are at start of a new identifier. */
    do
    {
        char       *curname;
        char       *endp;
 
        if (*nextp == '"')
        {
            /* Quoted name --- collapse quote-quote pairs */
            curname = nextp + 1;
            for (;;)
            {
                endp = strchr(nextp + 1, '"');
                if (endp == NULL)
                    return false;   /* mismatched quotes */
                if (endp[1] != '"')
                    break;      /* found end of quoted name */
                /* Collapse adjacent quotes into one quote, and look again */
                memmove(endp, endp + 1, strlen(endp));
                nextp = endp;
            }
            /* endp now points at the terminating quote */
            nextp = endp + 1;
        }
        else
        {
            /* Unquoted name --- extends to separator or whitespace */
            curname = nextp;
            while (*nextp && *nextp != separator &&
                   !isspace((unsigned char) *nextp))
                nextp++;
            endp = nextp;
            if (curname == nextp)
                return false;   /* empty unquoted name not allowed */
        }
 
        while (isspace((unsigned char) *nextp))
            nextp++;            /* skip trailing whitespace */
 
        if (*nextp == separator)
        {
            nextp++;
            while (isspace((unsigned char) *nextp))
                nextp++;        /* skip leading whitespace for next */
            /* we expect another name, so done remains false */
        }
        else if (*nextp == '\0')
            done = true;
        else
            return false;       /* invalid syntax */
 
        /* Now safe to overwrite separator with a null */
        *endp = '\0';
 
        /*
         * Finished isolating current name --- add it to output array
         */
        *nextptr++ = curname;
 
        /* Loop back if we didn't reach end of string */
    } while (!done);
 
    *nextptr = NULL;
    return true;
}

References pg_malloc().

Referenced by makeAlterConfigCommand().

valid_restrict_key()

bool valid_restrict_key

(

const char *

restrict_key

)

Definition at line 992 of file dumputils.c.

{
    return restrict_key != NULL &&
        restrict_key[0] != '\0' &&
        strspn(restrict_key, restrict_chars) == strlen(restrict_key);
}

References restrict_chars, and restrict_key.

Referenced by main().

variable_is_guc_list_quote()

bool variable_is_guc_list_quote

(

const char *

name

)

Definition at line 730 of file dumputils.c.

{
    if (pg_strcasecmp(name, "local_preload_libraries") == 0 ||
        pg_strcasecmp(name, "search_path") == 0 ||
        pg_strcasecmp(name, "session_preload_libraries") == 0 ||
        pg_strcasecmp(name, "shared_preload_libraries") == 0 ||
        pg_strcasecmp(name, "temp_tablespaces") == 0 ||
        pg_strcasecmp(name, "unix_socket_directories") == 0)
        return true;
    else
        return false;
}

References name, and pg_strcasecmp().

Referenced by dumpFunc(), and makeAlterConfigCommand().