common.h File Reference

#include <setjmp.h>
#include <signal.h>
#include "fe_utils/print.h"
#include "fe_utils/psqlscan.h"
#include "libpq-fe.h"

Include dependency graph for common.h:

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

Go to the source code of this file.

Functions
bool	openQueryOutputFile (const char *fname, FILE **fout, bool *is_pipe)
bool	setQFout (const char *fname)
char *	psql_get_variable (const char *varname, PsqlScanQuoteType quote, void *passthrough)
void	NoticeProcessor (void *arg, const char *message)
void	psql_setup_cancel_handler (void)
void	SetShellResultVariables (int wait_result)
PGresult *	PSQLexec (const char *query)
int	PSQLexecWatch (const char *query, const printQueryOpt *opt, FILE *printQueryFout, int min_rows)
bool	SendQuery (const char *query)
bool	is_superuser (void)
bool	standard_strings (void)
const char *	session_username (void)
void	expand_tilde (char **filename)
bool	recognized_connection_string (const char *connstr)

Variables
volatile sig_atomic_t	sigint_interrupt_enabled
sigjmp_buf	sigint_interrupt_jmp

Function Documentation

expand_tilde()

void expand_tilde

(

char **

filename

)

Definition at line 2180 of file common.c.

{
    if (!filename || !(*filename))
        return;
 
    /*
     * WIN32 doesn't use tilde expansion for file names. Also, it uses tilde
     * for short versions of long file names, though the tilde is usually
     * toward the end, not at the beginning.
     */
#ifndef WIN32
 
    /* try tilde expansion */
    if (**filename == '~')
    {
        char       *fn;
        char        oldp,
                   *p;
        struct passwd *pw;
        char        home[MAXPGPATH];
 
        fn = *filename;
        *home = '\0';
 
        p = fn + 1;
        while (*p != '/' && *p != '\0')
            p++;
 
        oldp = *p;
        *p = '\0';
 
        if (*(fn + 1) == '\0')
            get_home_path(home);    /* ~ or ~/ only */
        else if ((pw = getpwnam(fn + 1)) != NULL)
            strlcpy(home, pw->pw_dir, sizeof(home));    /* ~user */
 
        *p = oldp;
        if (strlen(home) != 0)
        {
            char       *newfn;
 
            newfn = psprintf("%s%s", home, p);
            free(fn);
            *filename = newfn;
        }
    }
#endif
}

References filename, fn(), free, get_home_path(), MAXPGPATH, psprintf(), and strlcpy().

Referenced by exec_command_edit(), exec_command_g(), exec_command_include(), exec_command_lo(), exec_command_out(), exec_command_s(), exec_command_write(), initializeInput(), parse_slash_copy(), and process_psqlrc().

is_superuser()

bool is_superuser

(

void

)

Definition at line 2119 of file common.c.

{
    const char *val;
 
    if (!pset.db)
        return false;
 
    val = PQparameterStatus(pset.db, "is_superuser");
 
    if (val && strcmp(val, "on") == 0)
        return true;
 
    return false;
}

References _psqlSettings::db, PQparameterStatus(), pset, and val.

NoticeProcessor()

void NoticeProcessor	(	void *	arg,
		const char *	message
	)

Definition at line 267 of file common.c.

{
    (void) arg;                 /* not used */
    pg_log_info("%s", message);
}

References arg, and pg_log_info.

Referenced by do_connect(), and main().

openQueryOutputFile()

bool openQueryOutputFile	(	const char *	fname,
		FILE **	fout,
		bool *	is_pipe
	)

Definition at line 56 of file common.c.

{
    if (!fname || fname[0] == '\0')
    {
        *fout = stdout;
        *is_pipe = false;
    }
    else if (*fname == '|')
    {
        fflush(NULL);
        *fout = popen(fname + 1, "w");
        *is_pipe = true;
    }
    else
    {
        *fout = fopen(fname, "w");
        *is_pipe = false;
    }
 
    if (*fout == NULL)
    {
        pg_log_error("%s: %m", fname);
        return false;
    }
 
    return true;
}

References fflush(), pg_log_error, and generate_unaccent_rules::stdout.

Referenced by setQFout(), and SetupGOutput().

psql_get_variable()

char* psql_get_variable	(	const char *	varname,
		PsqlScanQuoteType	quote,
		void *	passthrough
	)

Definition at line 176 of file common.c.

{
    char       *result = NULL;
    const char *value;
 
    /* In an inactive \if branch, suppress all variable substitutions */
    if (passthrough && !conditional_active((ConditionalStack) passthrough))
        return NULL;
 
    value = GetVariable(pset.vars, varname);
    if (!value)
        return NULL;
 
    switch (quote)
    {
        case PQUOTE_PLAIN:
            result = pg_strdup(value);
            break;
        case PQUOTE_SQL_LITERAL:
        case PQUOTE_SQL_IDENT:
            {
                /*
                 * For these cases, we use libpq's quoting functions, which
                 * assume the string is in the connection's client encoding.
                 */
                char       *escaped_value;
 
                if (!pset.db)
                {
                    pg_log_error("cannot escape without active connection");
                    return NULL;
                }
 
                if (quote == PQUOTE_SQL_LITERAL)
                    escaped_value =
                        PQescapeLiteral(pset.db, value, strlen(value));
                else
                    escaped_value =
                        PQescapeIdentifier(pset.db, value, strlen(value));
 
                if (escaped_value == NULL)
                {
                    const char *error = PQerrorMessage(pset.db);
 
                    pg_log_info("%s", error);
                    return NULL;
                }
 
                /*
                 * Rather than complicate the lexer's API with a notion of
                 * which free() routine to use, just pay the price of an extra
                 * strdup().
                 */
                result = pg_strdup(escaped_value);
                PQfreemem(escaped_value);
                break;
            }
        case PQUOTE_SHELL_ARG:
            {
                /*
                 * For this we use appendShellStringNoError, which is
                 * encoding-agnostic, which is fine since the shell probably
                 * is too.  In any case, the only special character is "'",
                 * which is not known to appear in valid multibyte characters.
                 */
                PQExpBufferData buf;
 
                initPQExpBuffer(&buf);
                if (!appendShellStringNoError(&buf, value))
                {
                    pg_log_error("shell command argument contains a newline or carriage return: \"%s\"",
                                 value);
                    free(buf.data);
                    return NULL;
                }
                result = buf.data;
                break;
            }
 
            /* No default: we want a compiler warning for missing cases */
    }
 
    return result;
}

References appendShellStringNoError(), buf, conditional_active(), _psqlSettings::db, error(), free, GetVariable(), initPQExpBuffer(), pg_log_error, pg_log_info, pg_strdup(), PQerrorMessage(), PQescapeIdentifier(), PQescapeLiteral(), PQfreemem(), PQUOTE_PLAIN, PQUOTE_SHELL_ARG, PQUOTE_SQL_IDENT, PQUOTE_SQL_LITERAL, pset, value, and _psqlSettings::vars.

psql_setup_cancel_handler()

void psql_setup_cancel_handler

(

void

)

Definition at line 313 of file common.c.

{
    setup_cancel_handler(psql_cancel_callback);
}

References psql_cancel_callback(), and setup_cancel_handler().

Referenced by main().

PSQLexec()

PGresult* PSQLexec

(

const char *

query

)

Definition at line 620 of file common.c.

{
    PGresult   *res;
 
    if (!pset.db)
    {
        pg_log_error("You are currently not connected to a database.");
        return NULL;
    }
 
    if (pset.echo_hidden != PSQL_ECHO_HIDDEN_OFF)
    {
        printf(_("/******** QUERY *********/\n"
                 "%s\n"
                 "/************************/\n\n"), query);
        fflush(stdout);
        if (pset.logfile)
        {
            fprintf(pset.logfile,
                    _("/******** QUERY *********/\n"
                      "%s\n"
                      "/************************/\n\n"), query);
            fflush(pset.logfile);
        }
 
        if (pset.echo_hidden == PSQL_ECHO_HIDDEN_NOEXEC)
            return NULL;
    }
 
    SetCancelConn(pset.db);
 
    res = PQexec(pset.db, query);
 
    ResetCancelConn();
 
    if (!AcceptResult(res, true))
    {
        ClearOrSaveResult(res);
        res = NULL;
    }
 
    return res;
}

References _, AcceptResult(), ClearOrSaveResult(), _psqlSettings::db, _psqlSettings::echo_hidden, fflush(), fprintf, _psqlSettings::logfile, pg_log_error, PQexec(), printf, pset, PSQL_ECHO_HIDDEN_NOEXEC, PSQL_ECHO_HIDDEN_OFF, res, ResetCancelConn(), SetCancelConn(), and generate_unaccent_rules::stdout.

Referenced by add_tablespace_footer(), addFooterToPublicationDesc(), describeAccessMethods(), describeAggregates(), describeConfigurationParameters(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describePublications(), describeRoleGrants(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), do_lo_import(), exec_command_password(), fail_lo_xact(), finish_lo_xact(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtendedStats(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listLargeObjects(), listOneExtensionContents(), listOperatorClasses(), listOperatorFamilies(), listOpFamilyFunctions(), listOpFamilyOperators(), listPartitionedTables(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSConfigsVerbose(), listTSDictionaries(), listTSParsers(), listTSParsersVerbose(), listTSTemplates(), listUserMappings(), main(), objectDescription(), permissionsList(), and start_lo_xact().

PSQLexecWatch()

int PSQLexecWatch	(	const char *	query,
		const printQueryOpt *	opt,
		FILE *	printQueryFout,
		int	min_rows
	)

Definition at line 675 of file common.c.

{
    bool        timing = pset.timing;
    double      elapsed_msec = 0;
    int         res;
 
    if (!pset.db)
    {
        pg_log_error("You are currently not connected to a database.");
        return 0;
    }
 
    SetCancelConn(pset.db);
 
    res = ExecQueryAndProcessResults(query, &elapsed_msec, NULL, true, min_rows, opt, printQueryFout);
 
    ResetCancelConn();
 
    /* Possible microtiming output */
    if (timing)
        PrintTiming(elapsed_msec);
 
    return res;
}

References _psqlSettings::db, ExecQueryAndProcessResults(), pg_log_error, PrintTiming(), pset, res, ResetCancelConn(), SetCancelConn(), and _psqlSettings::timing.

Referenced by do_watch().

recognized_connection_string()

bool recognized_connection_string

(

const char *

connstr

)

Definition at line 2265 of file common.c.

{
    return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
}

References connstr, and uri_prefix_length().

Referenced by do_connect().

SendQuery()

bool SendQuery

(

const char *

query

)

Definition at line 1082 of file common.c.

{
    bool        timing = pset.timing;
    PGTransactionStatusType transaction_status;
    double      elapsed_msec = 0;
    bool        OK = false;
    int         i;
    bool        on_error_rollback_savepoint = false;
    bool        svpt_gone = false;
 
    if (!pset.db)
    {
        pg_log_error("You are currently not connected to a database.");
        goto sendquery_cleanup;
    }
 
    if (pset.singlestep)
    {
        char        buf[3];
 
        fflush(stderr);
        printf(_("/**(Single step mode: verify command)******************************************/\n"
                 "%s\n"
                 "/**(press return to proceed or enter x and return to cancel)*******************/\n"),
               query);
        fflush(stdout);
        if (fgets(buf, sizeof(buf), stdin) != NULL)
            if (buf[0] == 'x')
                goto sendquery_cleanup;
        if (cancel_pressed)
            goto sendquery_cleanup;
    }
    else if (pset.echo == PSQL_ECHO_QUERIES)
    {
        puts(query);
        fflush(stdout);
    }
 
    if (pset.logfile)
    {
        fprintf(pset.logfile,
                _("/******** QUERY *********/\n"
                  "%s\n"
                  "/************************/\n\n"), query);
        fflush(pset.logfile);
    }
 
    SetCancelConn(pset.db);
 
    transaction_status = PQtransactionStatus(pset.db);
 
    if (transaction_status == PQTRANS_IDLE &&
        !pset.autocommit &&
        !command_no_begin(query))
    {
        PGresult   *result;
 
        result = PQexec(pset.db, "BEGIN");
        if (PQresultStatus(result) != PGRES_COMMAND_OK)
        {
            pg_log_info("%s", PQerrorMessage(pset.db));
            ClearOrSaveResult(result);
            goto sendquery_cleanup;
        }
        ClearOrSaveResult(result);
        transaction_status = PQtransactionStatus(pset.db);
    }
 
    if (transaction_status == PQTRANS_INTRANS &&
        pset.on_error_rollback != PSQL_ERROR_ROLLBACK_OFF &&
        (pset.cur_cmd_interactive ||
         pset.on_error_rollback == PSQL_ERROR_ROLLBACK_ON))
    {
        PGresult   *result;
 
        result = PQexec(pset.db, "SAVEPOINT pg_psql_temporary_savepoint");
        if (PQresultStatus(result) != PGRES_COMMAND_OK)
        {
            pg_log_info("%s", PQerrorMessage(pset.db));
            ClearOrSaveResult(result);
            goto sendquery_cleanup;
        }
        ClearOrSaveResult(result);
        on_error_rollback_savepoint = true;
    }
 
    if (pset.gdesc_flag)
    {
        /* Describe query's result columns, without executing it */
        OK = DescribeQuery(query, &elapsed_msec);
    }
    else
    {
        /* Default fetch-and-print mode */
        OK = (ExecQueryAndProcessResults(query, &elapsed_msec, &svpt_gone, false, 0, NULL, NULL) > 0);
    }
 
    if (!OK && pset.echo == PSQL_ECHO_ERRORS)
        pg_log_info("STATEMENT:  %s", query);
 
    /* If we made a temporary savepoint, possibly release/rollback */
    if (on_error_rollback_savepoint)
    {
        const char *svptcmd = NULL;
 
        transaction_status = PQtransactionStatus(pset.db);
 
        switch (transaction_status)
        {
            case PQTRANS_INERROR:
                /* We always rollback on an error */
                svptcmd = "ROLLBACK TO pg_psql_temporary_savepoint";
                break;
 
            case PQTRANS_IDLE:
                /* If they are no longer in a transaction, then do nothing */
                break;
 
            case PQTRANS_INTRANS:
 
                /*
                 * Release our savepoint, but do nothing if they are messing
                 * with savepoints themselves
                 */
                if (!svpt_gone)
                    svptcmd = "RELEASE pg_psql_temporary_savepoint";
                break;
 
            case PQTRANS_ACTIVE:
            case PQTRANS_UNKNOWN:
            default:
                OK = false;
                /* PQTRANS_UNKNOWN is expected given a broken connection. */
                if (transaction_status != PQTRANS_UNKNOWN || ConnectionUp())
                    pg_log_error("unexpected transaction status (%d)",
                                 transaction_status);
                break;
        }
 
        if (svptcmd)
        {
            PGresult   *svptres;
 
            svptres = PQexec(pset.db, svptcmd);
            if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
            {
                pg_log_info("%s", PQerrorMessage(pset.db));
                ClearOrSaveResult(svptres);
                OK = false;
 
                goto sendquery_cleanup;
            }
            PQclear(svptres);
        }
    }
 
    /* Possible microtiming output */
    if (timing)
        PrintTiming(elapsed_msec);
 
    /* check for events that may occur during query execution */
 
    if (pset.encoding != PQclientEncoding(pset.db) &&
        PQclientEncoding(pset.db) >= 0)
    {
        /* track effects of SET CLIENT_ENCODING */
        pset.encoding = PQclientEncoding(pset.db);
        pset.popt.topt.encoding = pset.encoding;
        SetVariable(pset.vars, "ENCODING",
                    pg_encoding_to_char(pset.encoding));
    }
 
    PrintNotifications();
 
    /* perform cleanup that should occur after any attempted query */
 
sendquery_cleanup:
 
    /* global cancellation reset */
    ResetCancelConn();
 
    /* reset \g's output-to-filename trigger */
    if (pset.gfname)
    {
        free(pset.gfname);
        pset.gfname = NULL;
    }
 
    /* restore print settings if \g changed them */
    if (pset.gsavepopt)
    {
        restorePsetInfo(&pset.popt, pset.gsavepopt);
        pset.gsavepopt = NULL;
    }
 
    /* clean up after \bind */
    if (pset.bind_flag)
    {
        for (i = 0; i < pset.bind_nparams; i++)
            free(pset.bind_params[i]);
        free(pset.bind_params);
        pset.bind_params = NULL;
        pset.bind_flag = false;
    }
 
    /* reset \gset trigger */
    if (pset.gset_prefix)
    {
        free(pset.gset_prefix);
        pset.gset_prefix = NULL;
    }
 
    /* reset \gdesc trigger */
    pset.gdesc_flag = false;
 
    /* reset \gexec trigger */
    pset.gexec_flag = false;
 
    /* reset \crosstabview trigger */
    pset.crosstab_flag = false;
    for (i = 0; i < lengthof(pset.ctv_args); i++)
    {
        pg_free(pset.ctv_args[i]);
        pset.ctv_args[i] = NULL;
    }
 
    return OK;
}

References _, _psqlSettings::autocommit, _psqlSettings::bind_flag, _psqlSettings::bind_nparams, _psqlSettings::bind_params, buf, cancel_pressed, ClearOrSaveResult(), command_no_begin(), ConnectionUp(), _psqlSettings::crosstab_flag, _psqlSettings::ctv_args, _psqlSettings::cur_cmd_interactive, _psqlSettings::db, DescribeQuery(), _psqlSettings::echo, _psqlSettings::encoding, printTableOpt::encoding, ExecQueryAndProcessResults(), fflush(), fprintf, free, _psqlSettings::gdesc_flag, _psqlSettings::gexec_flag, _psqlSettings::gfname, _psqlSettings::gsavepopt, _psqlSettings::gset_prefix, i, lengthof, _psqlSettings::logfile, _psqlSettings::on_error_rollback, pg_encoding_to_char, pg_free(), pg_log_error, pg_log_info, PGRES_COMMAND_OK, _psqlSettings::popt, PQclear(), PQclientEncoding(), PQerrorMessage(), PQexec(), PQresultStatus(), PQTRANS_ACTIVE, PQTRANS_IDLE, PQTRANS_INERROR, PQTRANS_INTRANS, PQTRANS_UNKNOWN, PQtransactionStatus(), printf, PrintNotifications(), PrintTiming(), pset, PSQL_ECHO_ERRORS, PSQL_ECHO_QUERIES, PSQL_ERROR_ROLLBACK_OFF, PSQL_ERROR_ROLLBACK_ON, ResetCancelConn(), restorePsetInfo(), SetCancelConn(), SetVariable(), _psqlSettings::singlestep, generate_unaccent_rules::stdout, _psqlSettings::timing, printQueryOpt::topt, and _psqlSettings::vars.

Referenced by do_copy(), ExecQueryTuples(), main(), and MainLoop().

session_username()

const char* session_username

(

void

)

Definition at line 2159 of file common.c.

{
    const char *val;
 
    if (!pset.db)
        return NULL;
 
    val = PQparameterStatus(pset.db, "session_authorization");
    if (val)
        return val;
    else
        return PQuser(pset.db);
}

References _psqlSettings::db, PQparameterStatus(), PQuser(), pset, and val.

Referenced by get_prompt().

setQFout()

bool setQFout

(

const char *

fname

)

Definition at line 132 of file common.c.

{
    FILE       *fout;
    bool        is_pipe;
 
    /* First make sure we can open the new output file/pipe */
    if (!openQueryOutputFile(fname, &fout, &is_pipe))
        return false;
 
    /* Close old file/pipe */
    if (pset.queryFout && pset.queryFout != stdout && pset.queryFout != stderr)
    {
        if (pset.queryFoutPipe)
            SetShellResultVariables(pclose(pset.queryFout));
        else
            fclose(pset.queryFout);
    }
 
    pset.queryFout = fout;
    pset.queryFoutPipe = is_pipe;
 
    /* Adjust SIGPIPE handling appropriately: ignore signal if is_pipe */
    set_sigpipe_trap_state(is_pipe);
    restore_sigpipe_trap();
 
    return true;
}

References openQueryOutputFile(), pset, _psqlSettings::queryFout, _psqlSettings::queryFoutPipe, restore_sigpipe_trap(), set_sigpipe_trap_state(), SetShellResultVariables(), and generate_unaccent_rules::stdout.

Referenced by exec_command_out(), main(), and parse_psql_options().

SetShellResultVariables()

void SetShellResultVariables

(

int

wait_result

)

Definition at line 501 of file common.c.

{
    char        buf[32];
 
    SetVariable(pset.vars, "SHELL_ERROR",
                (wait_result == 0) ? "false" : "true");
    snprintf(buf, sizeof(buf), "%d", wait_result_to_exit_code(wait_result));
    SetVariable(pset.vars, "SHELL_EXIT_CODE", buf);
}

References buf, pset, SetVariable(), snprintf, _psqlSettings::vars, and wait_result_to_exit_code().

Referenced by CloseGOutput(), do_copy(), do_shell(), exec_command_write(), and setQFout().

standard_strings()

bool standard_strings

(

void

)

Definition at line 2139 of file common.c.

{
    const char *val;
 
    if (!pset.db)
        return false;
 
    val = PQparameterStatus(pset.db, "standard_conforming_strings");
 
    if (val && strcmp(val, "on") == 0)
        return true;
 
    return false;
}

References _psqlSettings::db, PQparameterStatus(), pset, and val.

Referenced by get_create_object_cmd(), main(), MainLoop(), and parse_slash_copy().

Variable Documentation

sigint_interrupt_enabled

volatile sig_atomic_t sigint_interrupt_enabled

extern

Definition at line 292 of file common.c.

Referenced by exec_command_password(), exec_command_prompt(), gets_fromFile(), gets_interactive(), handleCopyIn(), MainLoop(), prompt_for_password(), and psql_cancel_callback().

sigint_interrupt_jmp

sigjmp_buf sigint_interrupt_jmp

extern

Definition at line 294 of file common.c.

Referenced by exec_command_password(), exec_command_prompt(), handleCopyIn(), MainLoop(), prompt_for_password(), and psql_cancel_callback().