#include "postgres_fe.h"
#include "common/connect.h"
#include "common/logging.h"
#include "common/string.h"
#include "connectdb.h"
#include "dumputils.h"
#include "fe_utils/string_utils.h"

Include dependency graph for connectdb.c:

Functions
static char *	constructConnStr (const char keywords, const char values)

PGconn *	ConnectDatabase (const char dbname, const char connection_string, const char pghost, const char pgport, const char pguser, trivalue prompt_password, bool fail_on_error, const char progname, const char *connstr, int server_version, char password, char override_dbname)

PGresult *	executeQuery (PGconn conn, const char query)

Function Documentation

◆ ConnectDatabase()

PGconn * ConnectDatabase	(	const char *	dbname,
		const char *	connection_string,
		const char *	pghost,
		const char *	pgport,
		const char *	pguser,
		trivalue	prompt_password,
		bool	fail_on_error,
		const char *	progname,
		const char **	connstr,
		int *	server_version,
		char *	password,
		char *	override_dbname
	)

Definition at line 40 of file connectdb.c.

{
    PGconn     *conn;
    bool        new_pass;
    const char *remoteversion_str;
    int         my_version;
    const char **keywords = NULL;
    const char **values = NULL;
    PQconninfoOption *conn_opts = NULL;
    int         server_version_temp;
 
    if (prompt_password == TRI_YES && !password)
        password = simple_prompt("Password: ", false);
 
    /*
     * Start the connection.  Loop until we have a password if requested by
     * backend.
     */
    do
    {
        int         argcount = 8;
        PQconninfoOption *conn_opt;
        char       *err_msg = NULL;
        int         i = 0;
 
        free(keywords);
        free(values);
        PQconninfoFree(conn_opts);
 
        /*
         * Merge the connection info inputs given in form of connection string
         * and other options.  Explicitly discard any dbname value in the
         * connection string; otherwise, PQconnectdbParams() would interpret
         * that value as being itself a connection string.
         */
        if (connection_string)
        {
            conn_opts = PQconninfoParse(connection_string, &err_msg);
            if (conn_opts == NULL)
                pg_fatal("%s", err_msg);
 
            for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
            {
                if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
                    strcmp(conn_opt->keyword, "dbname") != 0)
                    argcount++;
            }
 
            keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
            values = pg_malloc0((argcount + 1) * sizeof(*values));
 
            for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
            {
                if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
                    strcmp(conn_opt->keyword, "dbname") != 0)
                {
                    keywords[i] = conn_opt->keyword;
                    values[i] = conn_opt->val;
                    i++;
                }
            }
        }
        else
        {
            keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
            values = pg_malloc0((argcount + 1) * sizeof(*values));
        }
 
        if (pghost)
        {
            keywords[i] = "host";
            values[i] = pghost;
            i++;
        }
        if (pgport)
        {
            keywords[i] = "port";
            values[i] = pgport;
            i++;
        }
        if (pguser)
        {
            keywords[i] = "user";
            values[i] = pguser;
            i++;
        }
        if (password)
        {
            keywords[i] = "password";
            values[i] = password;
            i++;
        }
        if (dbname)
        {
            keywords[i] = "dbname";
            values[i] = dbname;
            i++;
        }
        if (override_dbname)
        {
            keywords[i] = "dbname";
            values[i] = override_dbname;
            i++;
        }
 
        keywords[i] = "fallback_application_name";
        values[i] = progname;
        i++;
 
        new_pass = false;
        conn = PQconnectdbParams(keywords, values, true);
 
        if (!conn)
            pg_fatal("could not connect to database \"%s\"", dbname);
 
        if (PQstatus(conn) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(conn) &&
            !password &&
            prompt_password != TRI_NO)
        {
            PQfinish(conn);
            password = simple_prompt("Password: ", false);
            new_pass = true;
        }
    } while (new_pass);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(conn) == CONNECTION_BAD)
    {
        if (fail_on_error)
            pg_fatal("%s", PQerrorMessage(conn));
        else
        {
            PQfinish(conn);
 
            free(keywords);
            free(values);
            PQconninfoFree(conn_opts);
 
            return NULL;
        }
    }
 
    /*
     * Ok, connected successfully. If requested, remember the options used, in
     * the form of a connection string.
     */
    if (connstr)
        *connstr = constructConnStr(keywords, values);
 
    free(keywords);
    free(values);
    PQconninfoFree(conn_opts);
 
    /* Check version */
    remoteversion_str = PQparameterStatus(conn, "server_version");
    if (!remoteversion_str)
        pg_fatal("could not get server version");
 
    server_version_temp = PQserverVersion(conn);
    if (server_version_temp == 0)
        pg_fatal("could not parse server version \"%s\"",
                 remoteversion_str);
 
    /* If requested, then copy server version to out variable. */
    if (server_version)
        *server_version = server_version_temp;
 
    my_version = PG_VERSION_NUM;
 
    /*
     * We allow the server to be back to 9.2, and up to any minor release of
     * our own major version.  (See also version check in pg_dump.c.)
     */
    if (my_version != server_version_temp
        && (server_version_temp < 90200 ||
            (server_version_temp / 100) > (my_version / 100)))
    {
        pg_log_error("aborting because of server version mismatch");
        pg_log_error_detail("server version: %s; %s version: %s",
                            remoteversion_str, progname, PG_VERSION);
        exit_nicely(1);
    }
 
    PQclear(executeQuery(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));
 
    return conn;
}

References ALWAYS_SECURE_SEARCH_PATH_SQL, conn, CONNECTION_BAD, connection_string, connstr, constructConnStr(), dbname, executeQuery(), exit_nicely(), free, i, _PQconninfoOption::keyword, keywords, password, pg_fatal, pg_log_error, pg_log_error_detail, pg_malloc0(), pghost, pgport, PQclear(), PQconnectdbParams(), PQconnectionNeedsPassword(), PQconninfoFree(), PQconninfoParse(), PQerrorMessage(), PQfinish(), PQparameterStatus(), PQserverVersion(), PQstatus(), progname, server_version, simple_prompt(), TRI_NO, TRI_YES, _PQconninfoOption::val, and values.

Referenced by ConnectDatabaseAhx(), main(), and restore_all_databases().

◆ constructConnStr()

static char * constructConnStr	(	const char **	keywords,
		const char **	values
	)

static

Definition at line 245 of file connectdb.c.

{
    PQExpBuffer buf = createPQExpBuffer();
    char       *connstr;
    int         i;
    bool        firstkeyword = true;
 
    /* Construct a new connection string in key='value' format. */
    for (i = 0; keywords[i] != NULL; i++)
    {
        if (strcmp(keywords[i], "dbname") == 0 ||
            strcmp(keywords[i], "password") == 0 ||
            strcmp(keywords[i], "fallback_application_name") == 0)
            continue;
 
        if (!firstkeyword)
            appendPQExpBufferChar(buf, ' ');
        firstkeyword = false;
        appendPQExpBuffer(buf, "%s=", keywords[i]);
        appendConnStrVal(buf, values[i]);
    }
 
    connstr = pg_strdup(buf->data);
    destroyPQExpBuffer(buf);
    return connstr;
}

References appendConnStrVal(), appendPQExpBuffer(), appendPQExpBufferChar(), buf, connstr, createPQExpBuffer(), destroyPQExpBuffer(), i, keywords, pg_strdup(), and values.

Referenced by ConnectDatabase().

◆ executeQuery()

PGresult * executeQuery	(	PGconn *	conn,
		const char *	query
	)

Definition at line 278 of file connectdb.c.

{
    PGresult   *res;
 
    pg_log_info("executing %s", query);
 
    res = PQexec(conn, query);
    if (!res ||
        PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        pg_log_error("query failed: %s", PQerrorMessage(conn));
        pg_log_error_detail("Query was: %s", query);
        PQfinish(conn);
        exit_nicely(1);
    }
 
    return res;
}

References conn, exit_nicely(), pg_log_error, pg_log_error_detail, pg_log_info, PGRES_TUPLES_OK, PQerrorMessage(), PQexec(), PQfinish(), and PQresultStatus().

Referenced by appendQualifiedRelation(), buildShSecLabels(), cluster_all_databases(), compile_database_list(), compile_relation_list_one_db(), ConnectDatabase(), connectDatabase(), dropDBs(), dropRoles(), dropTablespaces(), dumpDatabases(), dumpRoleGUCPrivs(), dumpRoleMembership(), dumpRoles(), dumpTablespaces(), dumpUserConfig(), expand_dbname_patterns(), get_dbnames_list_to_restore(), get_parallel_tabidx_list(), get_parallel_tables_list(), main(), reindex_all_databases(), retrieve_objects(), and vacuum_all_databases().

Functions

Function Documentation

◆ ConnectDatabase()

◆ constructConnStr()

◆ executeQuery()