streamutil.c File Reference

#include "postgres_fe.h"
#include <sys/time.h>
#include <unistd.h>
#include "access/xlog_internal.h"
#include "common/connect.h"
#include "common/fe_memutils.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "common/string.h"
#include "datatype/timestamp.h"
#include "port/pg_bswap.h"
#include "pqexpbuffer.h"
#include "receivelog.h"
#include "streamutil.h"

Include dependency graph for streamutil.c:

Go to the source code of this file.

Macros
#define	ERRCODE_DUPLICATE_OBJECT   "42710"
#define	MINIMUM_VERSION_FOR_SHOW_CMD   100000
#define	MINIMUM_VERSION_FOR_GROUP_ACCESS   110000

Functions
static bool	RetrieveDataDirCreatePerm (PGconn *conn)
PGconn *	GetConnection (void)
bool	RetrieveWalSegSize (PGconn *conn)
bool	RunIdentifySystem (PGconn *conn, char **sysid, TimeLineID *starttli, XLogRecPtr *startpos, char **db_name)
bool	CreateReplicationSlot (PGconn *conn, const char *slot_name, const char *plugin, bool is_temporary, bool is_physical, bool reserve_wal, bool slot_exists_ok)
bool	DropReplicationSlot (PGconn *conn, const char *slot_name)
TimestampTz	feGetCurrentTimestamp (void)
void	feTimestampDifference (TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
bool	feTimestampDifferenceExceeds (TimestampTz start_time, TimestampTz stop_time, int msec)
void	fe_sendint64 (int64 i, char *buf)
int64	fe_recvint64 (char *buf)

Variables
uint32	WalSegSz
const char *	progname
char *	connection_string = NULL
char *	dbhost = NULL
char *	dbuser = NULL
char *	dbport = NULL
char *	dbname = NULL
int	dbgetpassword = 0
static char *	password = NULL
PGconn *	conn = NULL

Macro Definition Documentation

ERRCODE_DUPLICATE_OBJECT

#define ERRCODE_DUPLICATE_OBJECT   "42710"

Definition at line 32 of file streamutil.c.

Referenced by AddEnumLabel(), AddRelationNewConstraints(), AlterTypeNamespaceInternal(), ATExecAddConstraint(), CastCreate(), CollationCreate(), ConversionCreate(), CreateAccessMethod(), CreateEventTrigger(), CreateExtension(), CreateForeignDataWrapper(), CreateForeignServer(), createNewConnection(), CreateOpFamily(), CreatePolicy(), CreateProceduralLanguage(), CreatePublication(), CreateReplicationSlot(), CreateRole(), CreateStatistics(), CreateSubscription(), CreateTableSpace(), CreateTransform(), CreateTrigger(), CreateUserMapping(), DefineCompositeType(), DefineDomain(), DefineEnum(), DefineOpClass(), DefineRange(), DefineType(), domainAddConstraint(), GetDefaultOpClass(), heap_create_with_catalog(), index_create(), InsertRule(), IsThereCollationInNamespace(), IsThereOpClassInNamespace(), IsThereOpFamilyInNamespace(), LogicalRepSyncTableStart(), makeArrayTypeName(), makeMultirangeTypeName(), MarkAsPreparing(), merge_publications(), MergeCheckConstraint(), MergeWithExistingConstraint(), publication_add_relation(), RegisterExtensibleNodeEntry(), rename_policy(), RenameConstraintById(), RenameEnumLabel(), RenameRewriteRule(), RenameRole(), RenameTableSpace(), renametrig(), RenameTypeInternal(), ReplicationSlotCreate(), report_name_conflict(), report_namespace_conflict(), storeOperators(), storeProcedures(), transformGenericOptions(), and TypeCreate().

MINIMUM_VERSION_FOR_GROUP_ACCESS

#define MINIMUM_VERSION_FOR_GROUP_ACCESS   110000

Definition at line 44 of file streamutil.c.

Referenced by RetrieveDataDirCreatePerm().

MINIMUM_VERSION_FOR_SHOW_CMD

#define MINIMUM_VERSION_FOR_SHOW_CMD   100000

Definition at line 39 of file streamutil.c.

Referenced by RetrieveWalSegSize().

Function Documentation

CreateReplicationSlot()

bool CreateReplicationSlot	(	PGconn *	conn,
		const char *	slot_name,
		const char *	plugin,
		bool	is_temporary,
		bool	is_physical,
		bool	reserve_wal,
		bool	slot_exists_ok
	)

Definition at line 487 of file streamutil.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ERRCODE_DUPLICATE_OBJECT, PG_DIAG_SQLSTATE, pg_log_error, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQexec(), PQnfields(), PQntuples(), PQresultErrorField(), PQresultStatus(), and PQserverVersion().

{
    PQExpBuffer query;
    PGresult   *res;

    query = createPQExpBuffer();

    Assert((is_physical && plugin == NULL) ||
           (!is_physical && plugin != NULL));
    Assert(slot_name != NULL);

    /* Build query */
    appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\"", slot_name);
    if (is_temporary)
        appendPQExpBufferStr(query, " TEMPORARY");
    if (is_physical)
    {
        appendPQExpBufferStr(query, " PHYSICAL");
        if (reserve_wal)
            appendPQExpBufferStr(query, " RESERVE_WAL");
    }
    else
    {
        appendPQExpBuffer(query, " LOGICAL \"%s\"", plugin);
        if (PQserverVersion(conn) >= 100000)
            /* pg_recvlogical doesn't use an exported snapshot, so suppress */
            appendPQExpBufferStr(query, " NOEXPORT_SNAPSHOT");
    }

    res = PQexec(conn, query->data);
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        const char *sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);

        if (slot_exists_ok &&
            sqlstate &&
            strcmp(sqlstate, ERRCODE_DUPLICATE_OBJECT) == 0)
        {
            destroyPQExpBuffer(query);
            PQclear(res);
            return true;
        }
        else
        {
            pg_log_error("could not send replication command \"%s\": %s",
                         query->data, PQerrorMessage(conn));

            destroyPQExpBuffer(query);
            PQclear(res);
            return false;
        }
    }

    if (PQntuples(res) != 1 || PQnfields(res) != 4)
    {
        pg_log_error("could not create replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields",
                     slot_name,
                     PQntuples(res), PQnfields(res), 1, 4);

        destroyPQExpBuffer(query);
        PQclear(res);
        return false;
    }

    destroyPQExpBuffer(query);
    PQclear(res);
    return true;
}

DropReplicationSlot()

bool DropReplicationSlot	(	PGconn *	conn,
		const char *	slot_name
	)

Definition at line 563 of file streamutil.c.

References appendPQExpBuffer(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), pg_log_error, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQnfields(), PQntuples(), and PQresultStatus().

{
    PQExpBuffer query;
    PGresult   *res;

    Assert(slot_name != NULL);

    query = createPQExpBuffer();

    /* Build query */
    appendPQExpBuffer(query, "DROP_REPLICATION_SLOT \"%s\"",
                      slot_name);
    res = PQexec(conn, query->data);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        pg_log_error("could not send replication command \"%s\": %s",
                     query->data, PQerrorMessage(conn));

        destroyPQExpBuffer(query);
        PQclear(res);
        return false;
    }

    if (PQntuples(res) != 0 || PQnfields(res) != 0)
    {
        pg_log_error("could not drop replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields",
                     slot_name,
                     PQntuples(res), PQnfields(res), 0, 0);

        destroyPQExpBuffer(query);
        PQclear(res);
        return false;
    }

    destroyPQExpBuffer(query);
    PQclear(res);
    return true;
}

fe_recvint64()

int64 fe_recvint64

(

char *

buf

)

Definition at line 673 of file streamutil.c.

References pg_ntoh64.

Referenced by ProcessXLogDataMsg(), and StreamLogicalLog().

{
    uint64      n64;

    memcpy(&n64, buf, sizeof(n64));

    return pg_ntoh64(n64);
}

fe_sendint64()

void fe_sendint64	(	int64	i,
		char *	buf
	)

Definition at line 662 of file streamutil.c.

References pg_hton64.

Referenced by sendFeedback().

{
    uint64      n64 = pg_hton64(i);

    memcpy(buf, &n64, sizeof(n64));
}

feGetCurrentTimestamp()

TimestampTz feGetCurrentTimestamp

(

void

)

Definition at line 608 of file streamutil.c.

References gettimeofday(), POSTGRES_EPOCH_JDATE, SECS_PER_DAY, UNIX_EPOCH_JDATE, and USECS_PER_SEC.

Referenced by flushAndSendFeedback(), HandleCopyStream(), ProcessKeepaliveMsg(), and StreamLogicalLog().

{
    TimestampTz result;
    struct timeval tp;

    gettimeofday(&tp, NULL);

    result = (TimestampTz) tp.tv_sec -
        ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
    result = (result * USECS_PER_SEC) + tp.tv_usec;

    return result;
}

feTimestampDifference()

void feTimestampDifference	(	TimestampTz	start_time,
		TimestampTz	stop_time,
		long *	secs,
		int *	microsecs
	)

Definition at line 627 of file streamutil.c.

References start_time, and USECS_PER_SEC.

Referenced by CalculateCopyStreamSleeptime(), and StreamLogicalLog().

{
    TimestampTz diff = stop_time - start_time;

    if (diff <= 0)
    {
        *secs = 0;
        *microsecs = 0;
    }
    else
    {
        *secs = (long) (diff / USECS_PER_SEC);
        *microsecs = (int) (diff % USECS_PER_SEC);
    }
}

feTimestampDifferenceExceeds()

bool feTimestampDifferenceExceeds	(	TimestampTz	start_time,
		TimestampTz	stop_time,
		int	msec
	)

Definition at line 649 of file streamutil.c.

References start_time.

Referenced by HandleCopyStream(), and StreamLogicalLog().

{
    TimestampTz diff = stop_time - start_time;

    return (diff >= msec * INT64CONST(1000));
}

GetConnection()

PGconn* GetConnection

(

void

)

Definition at line 62 of file streamutil.c.

References ALWAYS_SECURE_SEARCH_PATH_SQL, Assert, CONNECTION_BAD, CONNECTION_OK, connection_string, dbgetpassword, dbhost, dbname, dbport, dbuser, free, i, _PQconninfoOption::keyword, password, pg_log_error, pg_malloc0(), PGRES_TUPLES_OK, PQclear(), PQconnectdbParams(), PQconnectionNeedsPassword(), PQconninfoFree(), PQconninfoParse(), PQerrorMessage(), PQexec(), PQfinish(), PQparameterStatus(), PQresultStatus(), PQserverVersion(), PQstatus(), progname, RetrieveDataDirCreatePerm(), simple_prompt(), _PQconninfoOption::val, and values.

{
    PGconn     *tmpconn;
    int         argcount = 7;   /* dbname, replication, fallback_app_name,
                                 * host, user, port, password */
    int         i;
    const char **keywords;
    const char **values;
    const char *tmpparam;
    bool        need_password;
    PQconninfoOption *conn_opts = NULL;
    PQconninfoOption *conn_opt;
    char       *err_msg = NULL;

    /* pg_recvlogical uses dbname only; others use connection_string only. */
    Assert(dbname == NULL || connection_string == NULL);

    /*
     * Merge the connection info inputs given in form of connection string,
     * options and default values (dbname=replication, replication=true, etc.)
     * Explicitly discard any dbname value in the connection string;
     * otherwise, PQconnectdbParams() would interpret that value as being
     * itself a connection string.
     */
    i = 0;
    if (connection_string)
    {
        conn_opts = PQconninfoParse(connection_string, &err_msg);
        if (conn_opts == NULL)
        {
            pg_log_error("%s", err_msg);
            exit(1);
        }

        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));
    }

    keywords[i] = "dbname";
    values[i] = dbname == NULL ? "replication" : dbname;
    i++;
    keywords[i] = "replication";
    values[i] = dbname == NULL ? "true" : "database";
    i++;
    keywords[i] = "fallback_application_name";
    values[i] = progname;
    i++;

    if (dbhost)
    {
        keywords[i] = "host";
        values[i] = dbhost;
        i++;
    }
    if (dbuser)
    {
        keywords[i] = "user";
        values[i] = dbuser;
        i++;
    }
    if (dbport)
    {
        keywords[i] = "port";
        values[i] = dbport;
        i++;
    }

    /* If -W was given, force prompt for password, but only the first time */
    need_password = (dbgetpassword == 1 && !password);

    do
    {
        /* Get a new password if appropriate */
        if (need_password)
        {
            if (password)
                free(password);
            password = simple_prompt("Password: ", false);
            need_password = false;
        }

        /* Use (or reuse, on a subsequent connection) password if we have it */
        if (password)
        {
            keywords[i] = "password";
            values[i] = password;
        }
        else
        {
            keywords[i] = NULL;
            values[i] = NULL;
        }

        tmpconn = PQconnectdbParams(keywords, values, true);

        /*
         * If there is too little memory even to allocate the PGconn object
         * and PQconnectdbParams returns NULL, we call exit(1) directly.
         */
        if (!tmpconn)
        {
            pg_log_error("could not connect to server");
            exit(1);
        }

        /* If we need a password and -w wasn't given, loop back and get one */
        if (PQstatus(tmpconn) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(tmpconn) &&
            dbgetpassword != -1)
        {
            PQfinish(tmpconn);
            need_password = true;
        }
    }
    while (need_password);

    if (PQstatus(tmpconn) != CONNECTION_OK)
    {
        pg_log_error("%s", PQerrorMessage(tmpconn));
        PQfinish(tmpconn);
        free(values);
        free(keywords);
        if (conn_opts)
            PQconninfoFree(conn_opts);
        return NULL;
    }

    /* Connection ok! */
    free(values);
    free(keywords);
    if (conn_opts)
        PQconninfoFree(conn_opts);

    /*
     * Set always-secure search path, so malicious users can't get control.
     * The capacity to run normal SQL queries was added in PostgreSQL 10, so
     * the search path cannot be changed (by us or attackers) on earlier
     * versions.
     */
    if (dbname != NULL && PQserverVersion(tmpconn) >= 100000)
    {
        PGresult   *res;

        res = PQexec(tmpconn, ALWAYS_SECURE_SEARCH_PATH_SQL);
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
        {
            pg_log_error("could not clear search_path: %s",
                         PQerrorMessage(tmpconn));
            PQclear(res);
            PQfinish(tmpconn);
            exit(1);
        }
        PQclear(res);
    }

    /*
     * Ensure we have the same value of integer_datetimes (now always "on") as
     * the server we are connecting to.
     */
    tmpparam = PQparameterStatus(tmpconn, "integer_datetimes");
    if (!tmpparam)
    {
        pg_log_error("could not determine server setting for integer_datetimes");
        PQfinish(tmpconn);
        exit(1);
    }

    if (strcmp(tmpparam, "on") != 0)
    {
        pg_log_error("integer_datetimes compile flag does not match server");
        PQfinish(tmpconn);
        exit(1);
    }

    /*
     * Retrieve the source data directory mode and use it to construct a umask
     * for creating directories and files.
     */
    if (!RetrieveDataDirCreatePerm(tmpconn))
    {
        PQfinish(tmpconn);
        exit(1);
    }

    return tmpconn;
}

RetrieveDataDirCreatePerm()

static bool RetrieveDataDirCreatePerm ( PGconn *  conn )

static

Definition at line 355 of file streamutil.c.

References Assert, data_directory_mode, MINIMUM_VERSION_FOR_GROUP_ACCESS, pg_log_error, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQexec(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), PQserverVersion(), and SetDataDirectoryCreatePerm().

Referenced by GetConnection().

{
    PGresult   *res;
    int         data_directory_mode;

    /* check connection existence */
    Assert(conn != NULL);

    /* for previous versions leave the default group access */
    if (PQserverVersion(conn) < MINIMUM_VERSION_FOR_GROUP_ACCESS)
        return true;

    res = PQexec(conn, "SHOW data_directory_mode");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        pg_log_error("could not send replication command \"%s\": %s",
                     "SHOW data_directory_mode", PQerrorMessage(conn));

        PQclear(res);
        return false;
    }
    if (PQntuples(res) != 1 || PQnfields(res) < 1)
    {
        pg_log_error("could not fetch group access flag: got %d rows and %d fields, expected %d rows and %d or more fields",
                     PQntuples(res), PQnfields(res), 1, 1);

        PQclear(res);
        return false;
    }

    if (sscanf(PQgetvalue(res, 0, 0), "%o", &data_directory_mode) != 1)
    {
        pg_log_error("group access flag could not be parsed: %s",
                     PQgetvalue(res, 0, 0));

        PQclear(res);
        return false;
    }

    SetDataDirectoryCreatePerm(data_directory_mode);

    PQclear(res);
    return true;
}

RetrieveWalSegSize()

bool RetrieveWalSegSize

(

PGconn *

conn

)

Definition at line 277 of file streamutil.c.

References Assert, DEFAULT_XLOG_SEG_SIZE, IsValidWalSegSize, MINIMUM_VERSION_FOR_SHOW_CMD, ngettext, pg_log_error, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQexec(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), PQserverVersion(), and WalSegSz.

Referenced by main().

{
    PGresult   *res;
    char        xlog_unit[3];
    int         xlog_val,
                multiplier = 1;

    /* check connection existence */
    Assert(conn != NULL);

    /* for previous versions set the default xlog seg size */
    if (PQserverVersion(conn) < MINIMUM_VERSION_FOR_SHOW_CMD)
    {
        WalSegSz = DEFAULT_XLOG_SEG_SIZE;
        return true;
    }

    res = PQexec(conn, "SHOW wal_segment_size");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        pg_log_error("could not send replication command \"%s\": %s",
                     "SHOW wal_segment_size", PQerrorMessage(conn));

        PQclear(res);
        return false;
    }
    if (PQntuples(res) != 1 || PQnfields(res) < 1)
    {
        pg_log_error("could not fetch WAL segment size: got %d rows and %d fields, expected %d rows and %d or more fields",
                     PQntuples(res), PQnfields(res), 1, 1);

        PQclear(res);
        return false;
    }

    /* fetch xlog value and unit from the result */
    if (sscanf(PQgetvalue(res, 0, 0), "%d%s", &xlog_val, xlog_unit) != 2)
    {
        pg_log_error("WAL segment size could not be parsed");
        PQclear(res);
        return false;
    }

    PQclear(res);

    /* set the multiplier based on unit to convert xlog_val to bytes */
    if (strcmp(xlog_unit, "MB") == 0)
        multiplier = 1024 * 1024;
    else if (strcmp(xlog_unit, "GB") == 0)
        multiplier = 1024 * 1024 * 1024;

    /* convert and set WalSegSz */
    WalSegSz = xlog_val * multiplier;

    if (!IsValidWalSegSize(WalSegSz))
    {
        pg_log_error(ngettext("WAL segment size must be a power of two between 1 MB and 1 GB, but the remote server reported a value of %d byte",
                              "WAL segment size must be a power of two between 1 MB and 1 GB, but the remote server reported a value of %d bytes",
                              WalSegSz),
                     WalSegSz);
        return false;
    }

    return true;
}

RunIdentifySystem()

bool RunIdentifySystem	(	PGconn *	conn,
		char **	sysid,
		TimeLineID *	starttli,
		XLogRecPtr *	startpos,
		char **	db_name
	)

Definition at line 409 of file streamutil.c.

References Assert, pg_log_error, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQexec(), PQgetisnull(), PQgetvalue(), PQnfields(), PQntuples(), PQresultStatus(), and PQserverVersion().

Referenced by BaseBackup(), main(), and StreamLog().

{
    PGresult   *res;
    uint32      hi,
                lo;

    /* Check connection existence */
    Assert(conn != NULL);

    res = PQexec(conn, "IDENTIFY_SYSTEM");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        pg_log_error("could not send replication command \"%s\": %s",
                     "IDENTIFY_SYSTEM", PQerrorMessage(conn));

        PQclear(res);
        return false;
    }
    if (PQntuples(res) != 1 || PQnfields(res) < 3)
    {
        pg_log_error("could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields",
                     PQntuples(res), PQnfields(res), 1, 3);

        PQclear(res);
        return false;
    }

    /* Get system identifier */
    if (sysid != NULL)
        *sysid = pg_strdup(PQgetvalue(res, 0, 0));

    /* Get timeline ID to start streaming from */
    if (starttli != NULL)
        *starttli = atoi(PQgetvalue(res, 0, 1));

    /* Get LSN start position if necessary */
    if (startpos != NULL)
    {
        if (sscanf(PQgetvalue(res, 0, 2), "%X/%X", &hi, &lo) != 2)
        {
            pg_log_error("could not parse write-ahead log location \"%s\"",
                         PQgetvalue(res, 0, 2));

            PQclear(res);
            return false;
        }
        *startpos = ((uint64) hi) << 32 | lo;
    }

    /* Get database name, only available in 9.4 and newer versions */
    if (db_name != NULL)
    {
        *db_name = NULL;
        if (PQserverVersion(conn) >= 90400)
        {
            if (PQnfields(res) < 4)
            {
                pg_log_error("could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields",
                             PQntuples(res), PQnfields(res), 1, 4);

                PQclear(res);
                return false;
            }
            if (!PQgetisnull(res, 0, 3))
                *db_name = pg_strdup(PQgetvalue(res, 0, 3));
        }
    }

    PQclear(res);
    return true;
}

Variable Documentation

conn

PGconn* conn = NULL

Definition at line 54 of file streamutil.c.

Referenced by BaseBackup(), build_client_final_message(), build_client_first_message(), check_for_data_type_usage(), check_for_isn_and_int8_passing_mismatch(), check_for_jsonb_9_4_usage(), check_for_pg_role_prefix(), check_for_prepared_transactions(), check_for_reg_data_type_usage(), check_for_tables_with_oids(), check_for_user_defined_encoding_conversions(), check_for_user_defined_postfix_ops(), check_is_install_user(), check_loadable_libraries(), cluster_all_databases(), cluster_one_database(), connectDatabase(), connectMaintenanceDatabase(), connectToServer(), disconnect_atexit(), doConnect(), dumpBlobs(), dumpDatabase(), dumpDatabaseConfig(), dumpTableData_copy(), ExecuteSqlCommand(), freePGconn(), get_db_conn(), get_db_infos(), get_loadable_libraries(), get_rel_infos(), get_tablespace_paths(), init_libpq_source(), libpq_fetch_file(), libpq_get_current_wal_insert_lsn(), libpq_traverse_files(), libpqrcv_connect(), main(), makeEmptyPGconn(), new_9_0_populate_pg_largeobject_metadata(), old_9_6_invalidate_hash_indexes(), ParallelSlotClearHandler(), ParallelSlotsAdoptConn(), ParallelSlotsTerminate(), pg_fe_scram_exchange(), pg_fe_scram_init(), pgtls_write(), PQconnectdb(), PQconnectdbParams(), PQconnectStart(), PQconnectStartParams(), PQfireResultCreateEvents(), PQgetResult(), PQping(), PQpingParams(), PQregisterEventProc(), PQreset(), PQresetPoll(), PQsetdbLogin(), read_server_final_message(), read_server_first_message(), reindex_all_databases(), reindex_one_database(), run_permutation(), set_frozenxids(), setKeepalivesCount(), setup_connection(), sql_conn(), start_postmaster(), StartLogStreamer(), StreamLog(), StreamLogicalLog(), try_complete_step(), vacuum_all_databases(), vacuum_one_database(), and vacuumlo().

connection_string

char* connection_string = NULL

Definition at line 47 of file streamutil.c.

Referenced by GetConnection(), and main().

dbgetpassword

int dbgetpassword = 0

Definition at line 52 of file streamutil.c.

Referenced by GetConnection(), and main().

dbhost

char* dbhost = NULL

Definition at line 48 of file streamutil.c.

Referenced by GetConnection(), and main().

dbname

char* dbname = NULL

Definition at line 51 of file streamutil.c.

Referenced by _copyAlterDatabaseSetStmt(), _copyAlterDatabaseStmt(), _copyCreatedbStmt(), _copyDropdbStmt(), _equalAlterDatabaseSetStmt(), _equalAlterDatabaseStmt(), _equalCreatedbStmt(), _equalDropdbStmt(), AutoVacWorkerMain(), cluster_all_databases(), connect_slot(), connectDatabase(), conninfo_uri_parse_options(), convert_database_name(), createdb(), do_connect(), dropDBs(), dumpDatabaseConfig(), dumpDatabases(), ECPGconnect(), GetConnection(), IdentifySystem(), InitPostgres(), log_line_prefix(), main(), map_sql_catalog_to_xmlschema_types(), map_sql_schema_to_xmlschema_types(), objectNamesToOids(), ParallelSlotClearHandler(), and reindex_all_databases().

dbport

char* dbport = NULL

Definition at line 50 of file streamutil.c.

Referenced by GetConnection(), and main().

dbuser

char* dbuser = NULL

Definition at line 49 of file streamutil.c.

Referenced by GetConnection(), and main().

password

char* password = NULL

static

Definition at line 53 of file streamutil.c.

Referenced by AlterRole(), auth_peer(), check_password(), connectDatabase(), ConnectDatabase(), conninfo_uri_parse_options(), CreateRole(), do_connect(), doConnect(), GetConnection(), main(), pg_fe_sendauth(), pg_password_sendauth(), pg_SASL_init(), PQconnectionNeedsPassword(), PQpass(), sql_conn(), and vacuumlo().

progname

const char* progname

Definition at line 46 of file streamutil.c.

Referenced by GetConnection().

WalSegSz

uint32 WalSegSz

Definition at line 34 of file streamutil.c.

Referenced by AuxiliaryProcessMain(), close_walfile(), extractPageMap(), findLastCheckpoint(), FindStreamingStart(), main(), open_walfile(), ProcessXLogDataMsg(), readOneRecord(), ReceiveXlogStream(), RetrieveWalSegSize(), SimpleXLogPageRead(), StartLogStreamer(), and StreamLog().