2011-10-26 20:13:33 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* streamutil.c - utility functions for pg_basebackup and pg_receivelog
|
|
|
|
*
|
|
|
|
* Author: Magnus Hagander <magnus@hagander.net>
|
|
|
|
*
|
2015-01-06 17:43:47 +01:00
|
|
|
* Portions Copyright (c) 1996-2015, 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
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2014-03-18 17:19:57 +01:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
/* for ntohl/htonl */
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
|
|
|
|
/* local includes */
|
|
|
|
#include "receivelog.h"
|
|
|
|
#include "streamutil.h"
|
|
|
|
|
2014-10-01 17:22:21 +02:00
|
|
|
#include "pqexpbuffer.h"
|
2014-03-18 17:19:57 +01:00
|
|
|
#include "common/fe_memutils.h"
|
|
|
|
#include "datatype/timestamp.h"
|
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-02-01 04:45:17 +01:00
|
|
|
char *replication_slot = 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 */
|
|
|
|
static char *dbpassword = NULL;
|
|
|
|
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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.)
|
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++)
|
|
|
|
{
|
|
|
|
if (conn_opt->val != NULL && conn_opt->val[0] != '\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')
|
|
|
|
{
|
|
|
|
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 */
|
|
|
|
need_password = (dbgetpassword == 1 && dbpassword == NULL);
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
if (dbpassword)
|
|
|
|
free(dbpassword);
|
|
|
|
dbpassword = simple_prompt(_("Password: "), 100, false);
|
|
|
|
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 */
|
2011-10-26 20:13:33 +02:00
|
|
|
if (dbpassword)
|
|
|
|
{
|
2013-02-25 13:48:27 +01:00
|
|
|
keywords[i] = "password";
|
|
|
|
values[i] = dbpassword;
|
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)
|
|
|
|
{
|
|
|
|
fprintf(stderr, _("%s: could not connect to server: %s\n"),
|
|
|
|
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);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure we have the same value of integer timestamps as the server we
|
|
|
|
* are connecting to.
|
|
|
|
*/
|
|
|
|
tmpparam = PQparameterStatus(tmpconn, "integer_datetimes");
|
|
|
|
if (!tmpparam)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
_("%s: could not determine server setting for integer_datetimes\n"),
|
|
|
|
progname);
|
|
|
|
PQfinish(tmpconn);
|
|
|
|
exit(1);
|
|
|
|
}
|
2012-05-22 16:02:47 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_INT64_TIMESTAMP
|
2013-11-15 23:27:41 +01:00
|
|
|
if (strcmp(tmpparam, "on") != 0)
|
2012-05-22 16:02:47 +02:00
|
|
|
#else
|
2013-11-15 23:27:41 +01:00
|
|
|
if (strcmp(tmpparam, "off") != 0)
|
2012-05-22 16:02:47 +02:00
|
|
|
#endif
|
2013-11-15 23:27:41 +01:00
|
|
|
{
|
|
|
|
fprintf(stderr,
|
2012-07-31 16:11:11 +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
|
|
|
|
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:
|
|
|
|
* - Start LSN position
|
|
|
|
* - Current timeline ID
|
|
|
|
* - System identifier
|
|
|
|
* - Plugin name
|
|
|
|
*/
|
|
|
|
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,
|
2015-05-24 03:35:49 +02:00
|
|
|
_("%s: could not parse transaction 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
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
|
|
|
if (PQgetisnull(res, 0, 3))
|
2015-05-24 03:35:49 +02:00
|
|
|
*db_name = NULL;
|
2014-10-01 17:22:21 +02:00
|
|
|
else
|
|
|
|
*db_name = pg_strdup(PQgetvalue(res, 0, 3));
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a replication slot for the given connection. This function
|
|
|
|
* returns true in case of success as well as the start position
|
|
|
|
* obtained after the slot creation.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
CreateReplicationSlot(PGconn *conn, const char *slot_name, const char *plugin,
|
|
|
|
XLogRecPtr *startpos, bool is_physical)
|
|
|
|
{
|
|
|
|
PQExpBuffer query;
|
|
|
|
PGresult *res;
|
|
|
|
|
|
|
|
query = createPQExpBuffer();
|
|
|
|
|
|
|
|
Assert((is_physical && plugin == NULL) ||
|
|
|
|
(!is_physical && plugin != NULL));
|
|
|
|
Assert(slot_name != NULL);
|
|
|
|
|
|
|
|
/* Build query */
|
|
|
|
if (is_physical)
|
|
|
|
appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" PHYSICAL",
|
|
|
|
slot_name);
|
|
|
|
else
|
|
|
|
appendPQExpBuffer(query, "CREATE_REPLICATION_SLOT \"%s\" LOGICAL \"%s\"",
|
|
|
|
slot_name, plugin);
|
|
|
|
|
|
|
|
res = PQexec(conn, query->data);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_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) != 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get LSN start position if necessary */
|
|
|
|
if (startpos != NULL)
|
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
uint32 hi,
|
|
|
|
lo;
|
2014-10-01 17:22:21 +02:00
|
|
|
|
|
|
|
if (sscanf(PQgetvalue(res, 0, 1), "%X/%X", &hi, &lo) != 2)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
2015-05-24 03:35:49 +02:00
|
|
|
_("%s: could not parse transaction log location \"%s\"\n"),
|
2014-10-01 17:22:21 +02:00
|
|
|
progname, PQgetvalue(res, 0, 1));
|
2014-10-06 17:18:13 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(query);
|
|
|
|
PQclear(res);
|
2014-10-01 17:22:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*startpos = ((uint64) hi) << 32 | lo;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-03-18 17:19:57 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frontend version of GetCurrentTimestamp(), since we are not linked with
|
2014-10-01 17:22:21 +02:00
|
|
|
* backend code. The replication protocol always uses integer timestamps,
|
|
|
|
* regardless of the server setting.
|
2014-03-18 17:19:57 +01:00
|
|
|
*/
|
|
|
|
int64
|
|
|
|
feGetCurrentTimestamp(void)
|
|
|
|
{
|
|
|
|
int64 result;
|
|
|
|
struct timeval tp;
|
|
|
|
|
|
|
|
gettimeofday(&tp, NULL);
|
|
|
|
|
|
|
|
result = (int64) tp.tv_sec -
|
|
|
|
((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
|
|
|
|
feTimestampDifference(int64 start_time, int64 stop_time,
|
2014-05-06 18:12:18 +02:00
|
|
|
long *secs, int *microsecs)
|
2014-03-18 17:19:57 +01:00
|
|
|
{
|
|
|
|
int64 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frontend version of TimestampDifferenceExceeds(), since we are not
|
|
|
|
* linked with backend code.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
feTimestampDifferenceExceeds(int64 start_time,
|
2014-05-06 18:12:18 +02:00
|
|
|
int64 stop_time,
|
|
|
|
int msec)
|
2014-03-18 17:19:57 +01:00
|
|
|
{
|
|
|
|
int64 diff = stop_time - start_time;
|
|
|
|
|
|
|
|
return (diff >= msec * INT64CONST(1000));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Converts an int64 to network byte order.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
fe_sendint64(int64 i, char *buf)
|
|
|
|
{
|
|
|
|
uint32 n32;
|
|
|
|
|
|
|
|
/* High order half first, since we're doing MSB-first */
|
|
|
|
n32 = (uint32) (i >> 32);
|
|
|
|
n32 = htonl(n32);
|
|
|
|
memcpy(&buf[0], &n32, 4);
|
|
|
|
|
|
|
|
/* Now the low order half */
|
|
|
|
n32 = (uint32) i;
|
|
|
|
n32 = htonl(n32);
|
|
|
|
memcpy(&buf[4], &n32, 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Converts an int64 from network byte order to native format.
|
|
|
|
*/
|
|
|
|
int64
|
|
|
|
fe_recvint64(char *buf)
|
|
|
|
{
|
|
|
|
int64 result;
|
|
|
|
uint32 h32;
|
|
|
|
uint32 l32;
|
|
|
|
|
|
|
|
memcpy(&h32, buf, 4);
|
|
|
|
memcpy(&l32, buf + 4, 4);
|
|
|
|
h32 = ntohl(h32);
|
|
|
|
l32 = ntohl(l32);
|
|
|
|
|
|
|
|
result = h32;
|
|
|
|
result <<= 32;
|
|
|
|
result |= l32;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|