2011-10-26 20:13:33 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
2017-07-07 14:08:55 +02:00
|
|
|
* streamutil.c - utility functions for pg_basebackup, pg_receivewal and
|
|
|
|
* pg_recvlogical
|
2011-10-26 20:13:33 +02:00
|
|
|
*
|
|
|
|
* Author: Magnus Hagander <magnus@hagander.net>
|
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
|
2011-10-26 20:13:33 +02:00
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/bin/pg_basebackup/streamutil.c
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2012-12-13 13:59:13 +01:00
|
|
|
#include "postgres_fe.h"
|
2011-10-26 20:13:33 +02:00
|
|
|
|
2014-03-18 17:19:57 +01:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
/* local includes */
|
|
|
|
#include "receivelog.h"
|
|
|
|
#include "streamutil.h"
|
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
#include "access/xlog_internal.h"
|
2014-03-18 17:19:57 +01:00
|
|
|
#include "common/fe_memutils.h"
|
|
|
|
#include "datatype/timestamp.h"
|
Empty search_path in Autovacuum and non-psql/pgbench clients.
This makes the client programs behave as documented regardless of the
connect-time search_path and regardless of user-created objects. Today,
a malicious user with CREATE permission on a search_path schema can take
control of certain of these clients' queries and invoke arbitrary SQL
functions under the client identity, often a superuser. This is
exploitable in the default configuration, where all users have CREATE
privilege on schema "public".
This changes behavior of user-defined code stored in the database, like
pg_index.indexprs and pg_extension_config_dump(). If they reach code
bearing unqualified names, "does not exist" or "no schema has been
selected to create in" errors might appear. Users may fix such errors
by schema-qualifying affected names. After upgrading, consider watching
server logs for these errors.
The --table arguments of src/bin/scripts clients have been lax; for
example, "vacuumdb -Zt pg_am\;CHECKPOINT" performed a checkpoint. That
now fails, but for now, "vacuumdb -Zt 'pg_am(amname);CHECKPOINT'" still
performs a checkpoint.
Back-patch to 9.3 (all supported versions).
Reviewed by Tom Lane, though this fix strategy was not his first choice.
Reported by Arseniy Sharoglazov.
Security: CVE-2018-1058
2018-02-26 16:39:44 +01:00
|
|
|
#include "fe_utils/connect.h"
|
2017-10-02 00:36:14 +02:00
|
|
|
#include "port/pg_bswap.h"
|
|
|
|
#include "pqexpbuffer.h"
|
2011-10-26 20:13:33 +02:00
|
|
|
|
2015-07-12 22:06:27 +02:00
|
|
|
#define ERRCODE_DUPLICATE_OBJECT "42710"
|
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
uint32 WalSegSz;
|
|
|
|
|
|
|
|
/* SHOW command for replication connection was introduced in version 10 */
|
|
|
|
#define MINIMUM_VERSION_FOR_SHOW_CMD 100000
|
|
|
|
|
2011-10-26 20:13:33 +02:00
|
|
|
const char *progname;
|
2013-02-25 13:48:27 +01:00
|
|
|
char *connection_string = NULL;
|
2011-10-26 20:13:33 +02:00
|
|
|
char *dbhost = NULL;
|
|
|
|
char *dbuser = NULL;
|
|
|
|
char *dbport = NULL;
|
2014-03-18 17:19:57 +01:00
|
|
|
char *dbname = NULL;
|
2011-10-26 20:13:33 +02:00
|
|
|
int dbgetpassword = 0; /* 0=auto, -1=never, 1=always */
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
static bool have_password = false;
|
|
|
|
static char password[100];
|
2011-10-26 20:13:33 +02:00
|
|
|
PGconn *conn = NULL;
|
|
|
|
|
2012-05-27 11:05:24 +02:00
|
|
|
/*
|
|
|
|
* Connect to the server. Returns a valid PGconn pointer if connected,
|
|
|
|
* or NULL on non-permanent error. On permanent error, the function will
|
|
|
|
* call exit(1) directly.
|
|
|
|
*/
|
2011-10-26 20:13:33 +02:00
|
|
|
PGconn *
|
|
|
|
GetConnection(void)
|
|
|
|
{
|
|
|
|
PGconn *tmpconn;
|
2013-02-25 13:48:27 +01:00
|
|
|
int argcount = 7; /* dbname, replication, fallback_app_name,
|
|
|
|
* host, user, port, password */
|
2011-10-26 20:13:33 +02:00
|
|
|
int i;
|
|
|
|
const char **keywords;
|
|
|
|
const char **values;
|
2012-05-22 16:02:47 +02:00
|
|
|
const char *tmpparam;
|
2013-11-15 23:27:41 +01:00
|
|
|
bool need_password;
|
2013-02-25 13:48:27 +01:00
|
|
|
PQconninfoOption *conn_opts = NULL;
|
|
|
|
PQconninfoOption *conn_opt;
|
|
|
|
char *err_msg = NULL;
|
|
|
|
|
2016-08-08 16:07:46 +02:00
|
|
|
/* pg_recvlogical uses dbname only; others use connection_string only. */
|
|
|
|
Assert(dbname == NULL || connection_string == NULL);
|
|
|
|
|
2013-02-25 13:48:27 +01:00
|
|
|
/*
|
|
|
|
* Merge the connection info inputs given in form of connection string,
|
2013-05-29 22:58:43 +02:00
|
|
|
* options and default values (dbname=replication, replication=true, etc.)
|
2016-08-08 16:07:46 +02:00
|
|
|
* Explicitly discard any dbname value in the connection string;
|
|
|
|
* otherwise, PQconnectdbParams() would interpret that value as being
|
|
|
|
* itself a connection string.
|
2013-02-25 13:48:27 +01:00
|
|
|
*/
|
|
|
|
i = 0;
|
|
|
|
if (connection_string)
|
|
|
|
{
|
|
|
|
conn_opts = PQconninfoParse(connection_string, &err_msg);
|
|
|
|
if (conn_opts == NULL)
|
|
|
|
{
|
2013-07-16 02:04:14 +02:00
|
|
|
fprintf(stderr, "%s: %s", progname, err_msg);
|
2013-07-14 21:31:23 +02:00
|
|
|
exit(1);
|
2013-02-25 13:48:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
|
|
|
|
{
|
2016-08-08 16:07:46 +02:00
|
|
|
if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
|
|
|
|
strcmp(conn_opt->keyword, "dbname") != 0)
|
2013-02-25 13:48:27 +01:00
|
|
|
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++)
|
|
|
|
{
|
2016-08-08 16:07:46 +02:00
|
|
|
if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
|
|
|
|
strcmp(conn_opt->keyword, "dbname") != 0)
|
2013-02-25 13:48:27 +01:00
|
|
|
{
|
|
|
|
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";
|
2014-03-18 17:19:57 +01:00
|
|
|
values[i] = dbname == NULL ? "replication" : dbname;
|
2013-02-25 13:48:27 +01:00
|
|
|
i++;
|
|
|
|
keywords[i] = "replication";
|
2014-03-18 17:19:57 +01:00
|
|
|
values[i] = dbname == NULL ? "true" : "database";
|
2013-02-25 13:48:27 +01:00
|
|
|
i++;
|
|
|
|
keywords[i] = "fallback_application_name";
|
|
|
|
values[i] = progname;
|
|
|
|
i++;
|
2011-10-26 20:13:33 +02:00
|
|
|
|
|
|
|
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++;
|
|
|
|
}
|
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
/* If -W was given, force prompt for password, but only the first time */
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
need_password = (dbgetpassword == 1 && !have_password);
|
2013-11-15 23:27:41 +01:00
|
|
|
|
2013-11-22 03:46:43 +01:00
|
|
|
do
|
2011-10-26 20:13:33 +02:00
|
|
|
{
|
2013-11-15 23:27:41 +01:00
|
|
|
/* Get a new password if appropriate */
|
|
|
|
if (need_password)
|
|
|
|
{
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
simple_prompt("Password: ", password, sizeof(password), false);
|
|
|
|
have_password = true;
|
2013-11-15 23:27:41 +01:00
|
|
|
need_password = false;
|
|
|
|
}
|
2011-10-26 20:13:33 +02:00
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
/* Use (or reuse, on a subsequent connection) password if we have it */
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
if (have_password)
|
2011-10-26 20:13:33 +02:00
|
|
|
{
|
2013-02-25 13:48:27 +01:00
|
|
|
keywords[i] = "password";
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
values[i] = password;
|
2011-10-26 20:13:33 +02:00
|
|
|
}
|
2013-11-15 23:27:41 +01:00
|
|
|
else
|
2011-10-26 20:13:33 +02:00
|
|
|
{
|
2013-11-15 23:27:41 +01:00
|
|
|
keywords[i] = NULL;
|
|
|
|
values[i] = NULL;
|
2011-10-26 20:13:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
tmpconn = PQconnectdbParams(keywords, values, true);
|
|
|
|
|
2012-07-12 13:31:19 +02:00
|
|
|
/*
|
|
|
|
* If there is too little memory even to allocate the PGconn object
|
|
|
|
* and PQconnectdbParams returns NULL, we call exit(1) directly.
|
|
|
|
*/
|
|
|
|
if (!tmpconn)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not connect to server\n"),
|
|
|
|
progname);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
/* If we need a password and -w wasn't given, loop back and get one */
|
2011-10-26 20:13:33 +02:00
|
|
|
if (PQstatus(tmpconn) == CONNECTION_BAD &&
|
|
|
|
PQconnectionNeedsPassword(tmpconn) &&
|
|
|
|
dbgetpassword != -1)
|
|
|
|
{
|
2012-07-12 13:31:19 +02:00
|
|
|
PQfinish(tmpconn);
|
2013-11-15 23:27:41 +01:00
|
|
|
need_password = true;
|
2011-10-26 20:13:33 +02:00
|
|
|
}
|
2013-11-15 23:27:41 +01:00
|
|
|
}
|
2013-11-22 03:46:43 +01:00
|
|
|
while (need_password);
|
2011-10-26 20:13:33 +02:00
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
if (PQstatus(tmpconn) != CONNECTION_OK)
|
|
|
|
{
|
2015-06-23 02:39:41 +02:00
|
|
|
fprintf(stderr, _("%s: could not connect to server: %s"),
|
2013-11-15 23:27:41 +01:00
|
|
|
progname, PQerrorMessage(tmpconn));
|
|
|
|
PQfinish(tmpconn);
|
2011-10-26 20:13:33 +02:00
|
|
|
free(values);
|
|
|
|
free(keywords);
|
2013-02-25 13:48:27 +01:00
|
|
|
if (conn_opts)
|
|
|
|
PQconninfoFree(conn_opts);
|
2013-11-15 23:27:41 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2011-10-26 20:13:33 +02:00
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
/* Connection ok! */
|
|
|
|
free(values);
|
|
|
|
free(keywords);
|
|
|
|
if (conn_opts)
|
|
|
|
PQconninfoFree(conn_opts);
|
|
|
|
|
2018-03-18 13:08:25 +01:00
|
|
|
/*
|
|
|
|
* 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(conn) >= 100000)
|
Empty search_path in Autovacuum and non-psql/pgbench clients.
This makes the client programs behave as documented regardless of the
connect-time search_path and regardless of user-created objects. Today,
a malicious user with CREATE permission on a search_path schema can take
control of certain of these clients' queries and invoke arbitrary SQL
functions under the client identity, often a superuser. This is
exploitable in the default configuration, where all users have CREATE
privilege on schema "public".
This changes behavior of user-defined code stored in the database, like
pg_index.indexprs and pg_extension_config_dump(). If they reach code
bearing unqualified names, "does not exist" or "no schema has been
selected to create in" errors might appear. Users may fix such errors
by schema-qualifying affected names. After upgrading, consider watching
server logs for these errors.
The --table arguments of src/bin/scripts clients have been lax; for
example, "vacuumdb -Zt pg_am\;CHECKPOINT" performed a checkpoint. That
now fails, but for now, "vacuumdb -Zt 'pg_am(amname);CHECKPOINT'" still
performs a checkpoint.
Back-patch to 9.3 (all supported versions).
Reviewed by Tom Lane, though this fix strategy was not his first choice.
Reported by Arseniy Sharoglazov.
Security: CVE-2018-1058
2018-02-26 16:39:44 +01:00
|
|
|
{
|
|
|
|
PGresult *res;
|
|
|
|
|
|
|
|
res = PQexec(tmpconn, ALWAYS_SECURE_SEARCH_PATH_SQL);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not clear search_path: %s\n"),
|
|
|
|
progname, PQerrorMessage(tmpconn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(tmpconn);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
PQclear(res);
|
|
|
|
}
|
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
/*
|
2017-02-23 20:04:43 +01:00
|
|
|
* Ensure we have the same value of integer_datetimes (now always "on") as
|
|
|
|
* the server we are connecting to.
|
2013-11-15 23:27:41 +01:00
|
|
|
*/
|
|
|
|
tmpparam = PQparameterStatus(tmpconn, "integer_datetimes");
|
|
|
|
if (!tmpparam)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
_("%s: could not determine server setting for integer_datetimes\n"),
|
2013-11-15 23:27:41 +01:00
|
|
|
progname);
|
|
|
|
PQfinish(tmpconn);
|
|
|
|
exit(1);
|
|
|
|
}
|
2012-05-22 16:02:47 +02:00
|
|
|
|
2013-11-15 23:27:41 +01:00
|
|
|
if (strcmp(tmpparam, "on") != 0)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
_("%s: integer_datetimes compile flag does not match server\n"),
|
2013-11-15 23:27:41 +01:00
|
|
|
progname);
|
|
|
|
PQfinish(tmpconn);
|
|
|
|
exit(1);
|
2011-10-26 20:13:33 +02:00
|
|
|
}
|
2013-11-15 23:27:41 +01:00
|
|
|
|
|
|
|
return tmpconn;
|
2011-10-26 20:13:33 +02:00
|
|
|
}
|
2014-03-18 17:19:57 +01:00
|
|
|
|
Make WAL segment size configurable at initdb time.
For performance reasons a larger segment size than the default 16MB
can be useful. A larger segment size has two main benefits: Firstly,
in setups using archiving, it makes it easier to write scripts that
can keep up with higher amounts of WAL, secondly, the WAL has to be
written and synced to disk less frequently.
But at the same time large segment size are disadvantageous for
smaller databases. So far the segment size had to be configured at
compile time, often making it unrealistic to choose one fitting to a
particularly load. Therefore change it to a initdb time setting.
This includes a breaking changes to the xlogreader.h API, which now
requires the current segment size to be configured. For that and
similar reasons a number of binaries had to be taught how to recognize
the current segment size.
Author: Beena Emerson, editorialized by Andres Freund
Reviewed-By: Andres Freund, David Steele, Kuntal Ghosh, Michael
Paquier, Peter Eisentraut, Robert Hass, Tushar Ahuja
Discussion: https://postgr.es/m/CAOG9ApEAcQ--1ieKbhFzXSQPw_YLmepaa4hNdnY5+ZULpt81Mw@mail.gmail.com
2017-09-20 07:03:48 +02:00
|
|
|
/*
|
|
|
|
* From version 10, explicitly set wal segment size using SHOW wal_segment_size
|
|
|
|
* since ControlFile is not accessible here.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
RetrieveWalSegSize(PGconn *conn)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not send replication command \"%s\": %s\n"),
|
|
|
|
progname, "SHOW wal_segment_size", PQerrorMessage(conn));
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (PQntuples(res) != 1 || PQnfields(res) < 1)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not fetch WAL segment size: got %d rows and %d fields, expected %d rows and %d or more fields\n"),
|
|
|
|
progname, 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)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: WAL segment size could not be parsed\n"),
|
|
|
|
progname);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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))
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: WAL segment size must be a power of two between 1MB and 1GB, but the remote server reported a value of %d bytes\n"),
|
|
|
|
progname, WalSegSz);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-10-01 17:22:21 +02:00
|
|
|
/*
|
|
|
|
* Run IDENTIFY_SYSTEM through a given connection and give back to caller
|
|
|
|
* some result information if requested:
|
|
|
|
* - System identifier
|
2016-01-05 21:25:12 +01:00
|
|
|
* - Current timeline ID
|
|
|
|
* - Start LSN position
|
|
|
|
* - Database name (NULL in servers prior to 9.4)
|
2014-10-01 17:22:21 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
RunIdentifySystem(PGconn *conn, char **sysid, TimeLineID *starttli,
|
|
|
|
XLogRecPtr *startpos, char **db_name)
|
|
|
|
{
|
|
|
|
PGresult *res;
|
2015-05-24 03:35:49 +02:00
|
|
|
uint32 hi,
|
|
|
|
lo;
|
2014-10-01 17:22:21 +02:00
|
|
|
|
|
|
|
/* Check connection existence */
|
|
|
|
Assert(conn != NULL);
|
|
|
|
|
|
|
|
res = PQexec(conn, "IDENTIFY_SYSTEM");
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not send replication command \"%s\": %s"),
|
|
|
|
progname, "IDENTIFY_SYSTEM", PQerrorMessage(conn));
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (PQntuples(res) != 1 || PQnfields(res) < 3)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields\n"),
|
|
|
|
progname, PQntuples(res), PQnfields(res), 1, 3);
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
_("%s: could not parse write-ahead log location \"%s\"\n"),
|
2014-10-01 17:22:21 +02:00
|
|
|
progname, PQgetvalue(res, 0, 2));
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*startpos = ((uint64) hi) << 32 | lo;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get database name, only available in 9.4 and newer versions */
|
2015-05-24 03:35:49 +02:00
|
|
|
if (db_name != NULL)
|
2014-10-01 17:22:21 +02:00
|
|
|
{
|
2016-01-05 21:25:12 +01:00
|
|
|
*db_name = NULL;
|
|
|
|
if (PQserverVersion(conn) >= 90400)
|
|
|
|
{
|
|
|
|
if (PQnfields(res) < 4)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not identify system: got %d rows and %d fields, expected %d rows and %d or more fields\n"),
|
|
|
|
progname, PQntuples(res), PQnfields(res), 1, 4);
|
2014-10-01 17:22:21 +02:00
|
|
|
|
2016-01-05 21:25:12 +01:00
|
|
|
PQclear(res);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!PQgetisnull(res, 0, 3))
|
|
|
|
*db_name = pg_strdup(PQgetvalue(res, 0, 3));
|
|
|
|
}
|
2014-10-01 17:22:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a replication slot for the given connection. This function
|
2017-03-19 17:06:44 +01:00
|
|
|
* returns true in case of success.
|
2014-10-01 17:22:21 +02:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
CreateReplicationSlot(PGconn *conn, const char *slot_name, const char *plugin,
|
2017-09-26 22:07:52 +02:00
|
|
|
bool is_temporary, bool is_physical, bool reserve_wal,
|
|
|
|
bool slot_exists_ok)
|
2014-10-01 17:22:21 +02:00
|
|
|
{
|
|
|
|
PQExpBuffer query;
|
|
|
|
PGresult *res;
|
|
|
|
|
|
|
|
query = createPQExpBuffer();
|
|
|
|
|
|
|
|
Assert((is_physical && plugin == NULL) ||
|
|
|
|
(!is_physical && plugin != NULL));
|
|
|
|
Assert(slot_name != NULL);
|
|
|
|
|
|
|
|
/* Build query */
|
2017-09-26 22:07:52 +02:00
|
|
|
appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\"", slot_name);
|
|
|
|
if (is_temporary)
|
|
|
|
appendPQExpBuffer(query, " TEMPORARY");
|
2014-10-01 17:22:21 +02:00
|
|
|
if (is_physical)
|
2017-09-26 22:07:52 +02:00
|
|
|
{
|
|
|
|
appendPQExpBuffer(query, " PHYSICAL");
|
|
|
|
if (reserve_wal)
|
|
|
|
appendPQExpBuffer(query, " RESERVE_WAL");
|
|
|
|
}
|
2014-10-01 17:22:21 +02:00
|
|
|
else
|
2017-03-14 22:13:56 +01:00
|
|
|
{
|
2017-09-26 22:07:52 +02:00
|
|
|
appendPQExpBuffer(query, " LOGICAL \"%s\"", plugin);
|
2017-03-14 22:13:56 +01:00
|
|
|
if (PQserverVersion(conn) >= 100000)
|
|
|
|
/* pg_recvlogical doesn't use an exported snapshot, so suppress */
|
|
|
|
appendPQExpBuffer(query, " NOEXPORT_SNAPSHOT");
|
|
|
|
}
|
2014-10-01 17:22:21 +02:00
|
|
|
|
|
|
|
res = PQexec(conn, query->data);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
|
|
|
{
|
2015-07-12 22:06:27 +02:00
|
|
|
const char *sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
|
2014-10-06 17:18:13 +02:00
|
|
|
|
2015-08-12 17:35:50 +02:00
|
|
|
if (slot_exists_ok &&
|
|
|
|
sqlstate &&
|
|
|
|
strcmp(sqlstate, ERRCODE_DUPLICATE_OBJECT) == 0)
|
2015-07-12 22:06:27 +02:00
|
|
|
{
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not send replication command \"%s\": %s"),
|
|
|
|
progname, query->data, PQerrorMessage(conn));
|
|
|
|
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
|
|
|
return false;
|
|
|
|
}
|
2014-10-01 17:22:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (PQntuples(res) != 1 || PQnfields(res) != 4)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not create replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n"),
|
|
|
|
progname, slot_name,
|
|
|
|
PQntuples(res), PQnfields(res), 1, 4);
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-10-06 17:18:13 +02:00
|
|
|
destroyPQExpBuffer(query);
|
2014-10-01 17:22:21 +02:00
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop a replication slot for the given connection. This function
|
|
|
|
* returns true in case of success.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
DropReplicationSlot(PGconn *conn, const char *slot_name)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not send replication command \"%s\": %s"),
|
|
|
|
progname, query->data, PQerrorMessage(conn));
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PQntuples(res) != 0 || PQnfields(res) != 0)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not drop replication slot \"%s\": got %d rows and %d fields, expected %d rows and %d fields\n"),
|
|
|
|
progname, slot_name,
|
|
|
|
PQntuples(res), PQnfields(res), 0, 0);
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-07-12 22:25:51 +02:00
|
|
|
destroyPQExpBuffer(query);
|
2014-10-01 17:22:21 +02:00
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-03-18 17:19:57 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frontend version of GetCurrentTimestamp(), since we are not linked with
|
2017-02-23 21:57:08 +01:00
|
|
|
* backend code.
|
2014-03-18 17:19:57 +01:00
|
|
|
*/
|
2017-02-23 21:57:08 +01:00
|
|
|
TimestampTz
|
2014-03-18 17:19:57 +01:00
|
|
|
feGetCurrentTimestamp(void)
|
|
|
|
{
|
2017-02-23 21:57:08 +01:00
|
|
|
TimestampTz result;
|
2014-03-18 17:19:57 +01:00
|
|
|
struct timeval tp;
|
|
|
|
|
|
|
|
gettimeofday(&tp, NULL);
|
|
|
|
|
2017-02-23 21:57:08 +01:00
|
|
|
result = (TimestampTz) tp.tv_sec -
|
2014-03-18 17:19:57 +01:00
|
|
|
((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY);
|
|
|
|
result = (result * USECS_PER_SEC) + tp.tv_usec;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frontend version of TimestampDifference(), since we are not linked with
|
|
|
|
* backend code.
|
|
|
|
*/
|
|
|
|
void
|
2017-02-23 21:57:08 +01:00
|
|
|
feTimestampDifference(TimestampTz start_time, TimestampTz stop_time,
|
2014-05-06 18:12:18 +02:00
|
|
|
long *secs, int *microsecs)
|
2014-03-18 17:19:57 +01:00
|
|
|
{
|
2017-02-23 21:57:08 +01:00
|
|
|
TimestampTz diff = stop_time - start_time;
|
2014-03-18 17:19:57 +01:00
|
|
|
|
|
|
|
if (diff <= 0)
|
|
|
|
{
|
|
|
|
*secs = 0;
|
|
|
|
*microsecs = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*secs = (long) (diff / USECS_PER_SEC);
|
|
|
|
*microsecs = (int) (diff % USECS_PER_SEC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frontend version of TimestampDifferenceExceeds(), since we are not
|
|
|
|
* linked with backend code.
|
|
|
|
*/
|
|
|
|
bool
|
2017-02-23 21:57:08 +01:00
|
|
|
feTimestampDifferenceExceeds(TimestampTz start_time,
|
|
|
|
TimestampTz stop_time,
|
2014-05-06 18:12:18 +02:00
|
|
|
int msec)
|
2014-03-18 17:19:57 +01:00
|
|
|
{
|
2017-02-23 21:57:08 +01:00
|
|
|
TimestampTz diff = stop_time - start_time;
|
2014-03-18 17:19:57 +01:00
|
|
|
|
|
|
|
return (diff >= msec * INT64CONST(1000));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Converts an int64 to network byte order.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
fe_sendint64(int64 i, char *buf)
|
|
|
|
{
|
2017-10-02 00:36:14 +02:00
|
|
|
uint64 n64 = pg_hton64(i);
|
2014-03-18 17:19:57 +01:00
|
|
|
|
2017-10-02 00:36:14 +02:00
|
|
|
memcpy(buf, &n64, sizeof(n64));
|
2014-03-18 17:19:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Converts an int64 from network byte order to native format.
|
|
|
|
*/
|
|
|
|
int64
|
|
|
|
fe_recvint64(char *buf)
|
|
|
|
{
|
2017-10-02 00:36:14 +02:00
|
|
|
uint64 n64;
|
2014-03-18 17:19:57 +01:00
|
|
|
|
2017-10-02 00:36:14 +02:00
|
|
|
memcpy(&n64, buf, sizeof(n64));
|
2014-03-18 17:19:57 +01:00
|
|
|
|
2017-10-02 00:36:14 +02:00
|
|
|
return pg_ntoh64(n64);
|
2014-03-18 17:19:57 +01:00
|
|
|
}
|