recovery_gen.c File Reference

#include "postgres_fe.h"
#include "common/logging.h"
#include "fe_utils/recovery_gen.h"
#include "fe_utils/string_utils.h"

Include dependency graph for recovery_gen.c:

Go to the source code of this file.

Functions
static char *	escape_quotes (const char *src)
static char *	FindDbnameInConnOpts (PQconninfoOption *conn_opts)
PQExpBuffer	GenerateRecoveryConfig (PGconn *pgconn, const char *replication_slot, char *dbname)
void	WriteRecoveryConfig (PGconn *pgconn, const char *target_dir, PQExpBuffer contents)
char *	GetDbnameFromConnectionOptions (const char *connstr)

Function Documentation

escape_quotes()

static char * escape_quotes ( const char *  src )

static

Definition at line 164 of file recovery_gen.c.

{
    char       *result = escape_single_quotes_ascii(src);
 
    if (!result)
        pg_fatal("out of memory");
    return result;
}

References escape_single_quotes_ascii(), and pg_fatal.

Referenced by GenerateRecoveryConfig().

FindDbnameInConnOpts()

static char * FindDbnameInConnOpts ( PQconninfoOption *  conn_opts )

static

Definition at line 181 of file recovery_gen.c.

{
    for (PQconninfoOption *conn_opt = conn_opts;
         conn_opt->keyword != NULL;
         conn_opt++)
    {
        if (strcmp(conn_opt->keyword, "dbname") == 0 &&
            conn_opt->val != NULL && conn_opt->val[0] != '\0')
            return pg_strdup(conn_opt->val);
    }
    return NULL;
}

References _PQconninfoOption::keyword, and pg_strdup().

Referenced by GetDbnameFromConnectionOptions().

GenerateRecoveryConfig()

PQExpBuffer GenerateRecoveryConfig	(	PGconn *	pgconn,
		const char *	replication_slot,
		char *	dbname
	)

Definition at line 28 of file recovery_gen.c.

{
    PQconninfoOption *connOptions;
    PQExpBufferData conninfo_buf;
    char       *escaped;
    PQExpBuffer contents;
 
    Assert(pgconn != NULL);
 
    contents = createPQExpBuffer();
    if (!contents)
        pg_fatal("out of memory");
 
    /*
     * In PostgreSQL 12 and newer versions, standby_mode is gone, replaced by
     * standby.signal to trigger a standby state at recovery.
     */
    if (PQserverVersion(pgconn) < MINIMUM_VERSION_FOR_RECOVERY_GUC)
        appendPQExpBufferStr(contents, "standby_mode = 'on'\n");
 
    connOptions = PQconninfo(pgconn);
    if (connOptions == NULL)
        pg_fatal("out of memory");
 
    initPQExpBuffer(&conninfo_buf);
    for (PQconninfoOption *opt = connOptions; opt && opt->keyword; opt++)
    {
        /* Omit empty settings and those libpqwalreceiver overrides. */
        if (strcmp(opt->keyword, "replication") == 0 ||
            strcmp(opt->keyword, "dbname") == 0 ||
            strcmp(opt->keyword, "fallback_application_name") == 0 ||
            (opt->val == NULL) ||
            (opt->val != NULL && opt->val[0] == '\0'))
            continue;
 
        /* Separate key-value pairs with spaces */
        if (conninfo_buf.len != 0)
            appendPQExpBufferChar(&conninfo_buf, ' ');
 
        /*
         * Write "keyword=value" pieces, the value string is escaped and/or
         * quoted if necessary.
         */
        appendPQExpBuffer(&conninfo_buf, "%s=", opt->keyword);
        appendConnStrVal(&conninfo_buf, opt->val);
    }
 
    if (dbname)
    {
        /*
         * If dbname is specified in the connection, append the dbname. This
         * will be used later for logical replication slot synchronization.
         */
        if (conninfo_buf.len != 0)
            appendPQExpBufferChar(&conninfo_buf, ' ');
 
        appendPQExpBuffer(&conninfo_buf, "%s=", "dbname");
        appendConnStrVal(&conninfo_buf, dbname);
    }
 
    if (PQExpBufferDataBroken(conninfo_buf))
        pg_fatal("out of memory");
 
    /*
     * Escape the connection string, so that it can be put in the config file.
     * Note that this is different from the escaping of individual connection
     * options above!
     */
    escaped = escape_quotes(conninfo_buf.data);
    termPQExpBuffer(&conninfo_buf);
    appendPQExpBuffer(contents, "primary_conninfo = '%s'\n", escaped);
    free(escaped);
 
    if (replication_slot)
    {
        /* unescaped: ReplicationSlotValidateName allows [a-z0-9_] only */
        appendPQExpBuffer(contents, "primary_slot_name = '%s'\n",
                          replication_slot);
    }
 
    if (PQExpBufferBroken(contents))
        pg_fatal("out of memory");
 
    PQconninfoFree(connOptions);
 
    return contents;
}

References appendConnStrVal(), appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), Assert(), createPQExpBuffer(), PQExpBufferData::data, dbname, escape_quotes(), free, initPQExpBuffer(), _PQconninfoOption::keyword, PQExpBufferData::len, MINIMUM_VERSION_FOR_RECOVERY_GUC, pg_fatal, PQconninfo(), PQconninfoFree(), PQExpBufferBroken, PQExpBufferDataBroken, PQserverVersion(), replication_slot, and termPQExpBuffer().

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

GetDbnameFromConnectionOptions()

char * GetDbnameFromConnectionOptions

(

const char *

connstr

)

Definition at line 204 of file recovery_gen.c.

{
    PQconninfoOption *conn_opts;
    char       *err_msg = NULL;
    char       *dbname;
 
    /* First try to get the dbname from connection string. */
    if (connstr)
    {
        conn_opts = PQconninfoParse(connstr, &err_msg);
        if (conn_opts == NULL)
            pg_fatal("%s", err_msg);
 
        dbname = FindDbnameInConnOpts(conn_opts);
 
        PQconninfoFree(conn_opts);
        if (dbname)
            return dbname;
    }
 
    /*
     * Next try to get the dbname from default values that are available from
     * the environment.
     */
    conn_opts = PQconndefaults();
    if (conn_opts == NULL)
        pg_fatal("out of memory");
 
    dbname = FindDbnameInConnOpts(conn_opts);
 
    PQconninfoFree(conn_opts);
    return dbname;
}

References connstr, dbname, FindDbnameInConnOpts(), pg_fatal, PQconndefaults(), PQconninfoFree(), and PQconninfoParse().

Referenced by BaseBackup(), and main().

WriteRecoveryConfig()

void WriteRecoveryConfig	(	PGconn *	pgconn,
		const char *	target_dir,
		PQExpBuffer	contents
	)

Definition at line 125 of file recovery_gen.c.

{
    char        filename[MAXPGPATH];
    FILE       *cf;
    bool        use_recovery_conf;
 
    Assert(pgconn != NULL);
 
    use_recovery_conf =
        PQserverVersion(pgconn) < MINIMUM_VERSION_FOR_RECOVERY_GUC;
 
    snprintf(filename, MAXPGPATH, "%s/%s", target_dir,
             use_recovery_conf ? "recovery.conf" : "postgresql.auto.conf");
 
    cf = fopen(filename, use_recovery_conf ? "w" : "a");
    if (cf == NULL)
        pg_fatal("could not open file \"%s\": %m", filename);
 
    if (fwrite(contents->data, contents->len, 1, cf) != 1)
        pg_fatal("could not write to file \"%s\": %m", filename);
 
    fclose(cf);
 
    if (!use_recovery_conf)
    {
        snprintf(filename, MAXPGPATH, "%s/%s", target_dir, "standby.signal");
        cf = fopen(filename, "w");
        if (cf == NULL)
            pg_fatal("could not create file \"%s\": %m", filename);
 
        fclose(cf);
    }
}

References Assert(), PQExpBufferData::data, filename, PQExpBufferData::len, MAXPGPATH, MINIMUM_VERSION_FOR_RECOVERY_GUC, pg_fatal, PQserverVersion(), and snprintf.

Referenced by main(), and setup_recovery().