pq_connect.c File Reference

functions to connect to libpq (PostGres) More...

#include "platform.h"
#include "pq.h"
#include <poll.h>
#include <pthread.h>

Include dependency graph for pq_connect.c:

Go to the source code of this file.

Macros
#define	PSQL_OUTPUT_BYTES   (64 * 1024)
	Maximum stderr tail retained from one psql invocation.
#define	PSQL_OUTPUT_LINES   250
	Maximum number of retained stderr lines emitted on failure.

Functions
static void	reset_connection (struct GNUNET_PQ_Context *db)
	Close connection to db and mark it as uninitialized.
static enum GNUNET_GenericReturnValue	prepare_check_patch (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_check_patch" statement.
static enum GNUNET_GenericReturnValue	prepare_get_oid_by_name (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_get_oid_by_name" statement.
static enum GNUNET_GenericReturnValue	check_versioning_ok (struct GNUNET_PQ_Context *db)
	Check if the "_v" versioning schema exists (and cache the result in db).
static enum GNUNET_GenericReturnValue	check_patch_applied (struct GNUNET_PQ_Context *db, const char *load_path, unsigned int patch_number)
	Check if the patch with patch_number from the given load_path was already applied on the db.
static void	pq_notice_receiver_cb (void *arg, const PGresult *res)
	Function called by libpq whenever it wants to log something.
static void	pq_notice_processor_cb (void *arg, const char *message)
	Function called by libpq whenever it wants to log something.
static char *	get_sql_file_name (const struct GNUNET_PQ_Context *db, const char *infix)
	Construct the name of the SQL file with the given filename infix in the load path of db.
static enum GNUNET_GenericReturnValue	patch_file_exists (const struct GNUNET_PQ_Context *db, const char *load_suffix, unsigned int patch_number)
	Check if the SQL file for the patch with the given patch_number exists in the load path of db.
static bool	find_next_patch (const struct GNUNET_PQ_Context *db, const char *load_suffix, unsigned int from, unsigned int *found)
	Find the lowest patch number of at least from for which an SQL file exists in the load path of db.
static void	log_psql_output (char *output, size_t size, bool truncated)
	Log the last lines of captured psql stderr through the component logger.
enum GNUNET_GenericReturnValue	GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db, const char *buf)
	Execute SQL statements from buf against db.
enum GNUNET_GenericReturnValue	GNUNET_PQ_check_current (struct GNUNET_PQ_Context *db, const char *load_suffix)
	Check if the database is current with respect to database migrations using prefix.
enum GNUNET_GenericReturnValue	GNUNET_PQ_run_sql (struct GNUNET_PQ_Context *db, const char *load_suffix)
	Within the db context, run all the SQL files in the load path where the name starts with the load_suffix and ends with consecutive numbers from "[0000-9999].sql".
void	GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db)
	Reinitialize the database db if the connection is down.
enum GNUNET_GenericReturnValue	GNUNET_PQ_get_oid_by_name (struct GNUNET_PQ_Context *db, const char *name, Oid *oid)
	Returns the oid for a given datatype by name.
static enum GNUNET_GenericReturnValue	load_initial_oids (struct GNUNET_PQ_Context *db)
	Load the initial set of OIDs for the supported array-datatypes.
void	GNUNET_PQ_reconnect_ (struct GNUNET_PQ_Context *db)
	Reinitialize the database db.
enum GNUNET_GenericReturnValue	GNUNET_PQ_load_versioning (struct GNUNET_PQ_Context *db)
	Setup database versioning.
struct GNUNET_PQ_Context *	GNUNET_PQ_init (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_PQ_ReconnectCallback rc, GNUNET_PQ_RECONNECT_CALLBACK_CLOSURE *rc_cls)
void	GNUNET_PQ_disconnect (struct GNUNET_PQ_Context *db)
	Disconnect from the database, destroying the prepared statements and releasing other associated resources.

Detailed Description

functions to connect to libpq (PostGres)

Author

Christian Grothoff

Özgür Kesim

Definition in file pq_connect.c.

Macro Definition Documentation

PSQL_OUTPUT_BYTES

#define PSQL_OUTPUT_BYTES   (64 * 1024)

Maximum stderr tail retained from one psql invocation.

Definition at line 33 of file pq_connect.c.

PSQL_OUTPUT_LINES

#define PSQL_OUTPUT_LINES   250

Maximum number of retained stderr lines emitted on failure.

Definition at line 36 of file pq_connect.c.

Function Documentation

reset_connection()

static void reset_connection ( struct GNUNET_PQ_Context *  db )

static

Close connection to db and mark it as uninitialized.

Parameters

[in,out]

db

connection to close

Definition at line 45 of file pq_connect.c.

{
  if (NULL == db->conn)
    return;
  PQfinish (db->conn);
  db->conn = NULL;
  db->prepared_check_patch = false;
  db->prepared_get_oid_by_name = false;
}

References db.

Referenced by GNUNET_PQ_reconnect_(), prepare_check_patch(), and prepare_get_oid_by_name().

Here is the caller graph for this function:

prepare_check_patch()

static enum GNUNET_GenericReturnValue prepare_check_patch ( struct GNUNET_PQ_Context *  db )

static

Prepare the "gnunet_pq_check_patch" statement.

Parameters

[in,out]

db

database to prepare statement for

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 64 of file pq_connect.c.

{
  PGresult *res;
 
  if (db->prepared_check_patch)
    return GNUNET_OK;
  res = PQprepare (db->conn,
                   "gnunet_pq_check_patch",
                   "SELECT"
                   " applied_by"
                   " FROM _v.patches"
                   " WHERE patch_name = $1"
                   " LIMIT 1",
                   1,
                   NULL);
  if (PGRES_COMMAND_OK !=
      PQresultStatus (res))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL logic to setup database versioning logic: %s/%s\n",
                PQresultErrorMessage (res),
                PQerrorMessage (db->conn));
    PQclear (res);
    reset_connection (db);
    return GNUNET_SYSERR;
  }
  PQclear (res);
  db->prepared_check_patch = true;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, res, and reset_connection().

Referenced by check_patch_applied().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_get_oid_by_name()

static enum GNUNET_GenericReturnValue prepare_get_oid_by_name ( struct GNUNET_PQ_Context *  db )

static

Prepare the "gnunet_pq_get_oid_by_name" statement.

Parameters

[in,out]

db

database to prepare statement for

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 104 of file pq_connect.c.

{
  PGresult *res;
 
  if (db->prepared_get_oid_by_name)
    return GNUNET_OK;
  res = PQprepare (db->conn,
                   "gnunet_pq_get_oid_by_name",
                   "SELECT typname, oid"
                   "  FROM pg_type"
                   " WHERE oid = to_regtype($1)",
                   1,
                   NULL);
  if (PGRES_COMMAND_OK != PQresultStatus (res))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL statement prepare OID lookups: %s/%s\n",
                PQresultErrorMessage (res),
                PQerrorMessage (db->conn));
    PQclear (res);
    reset_connection (db);
    return GNUNET_SYSERR;
  }
  PQclear (res);
  db->prepared_get_oid_by_name = true;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, res, and reset_connection().

Referenced by GNUNET_PQ_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

check_versioning_ok()

static enum GNUNET_GenericReturnValue check_versioning_ok ( struct GNUNET_PQ_Context *  db )

static

Check if the "_v" versioning schema exists (and cache the result in db).

Parameters

[in,out]

db

connection to check

Returns

GNUNET_OK if versioning is OK GNUNET_NO if it is not loaded GNUNET_SYSERR if we encountered an error

Definition at line 143 of file pq_connect.c.

{
  PGresult *res;
  ExecStatusType est;
 
  if (GNUNET_OK == db->versioning_ok)
    return GNUNET_OK;
  if (GNUNET_NO == db->versioning_ok)
    return GNUNET_NO;
  res = PQexec (db->conn,
                "SELECT"
                " schema_name"
                " FROM information_schema.schemata"
                " WHERE schema_name='_v';");
  est = PQresultStatus (res);
  if ( (PGRES_COMMAND_OK != est) &&
       (PGRES_TUPLES_OK != est) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run statement to check versioning schema. Bad!\n");
    PQclear (res);
    return GNUNET_SYSERR;
  }
  if (0 == PQntuples (res))
  {
    PQclear (res);
    db->versioning_ok = GNUNET_NO;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "_v schema not found\n");
    return GNUNET_NO;
  }
  PQclear (res);
  db->versioning_ok = GNUNET_OK;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and res.

Referenced by check_patch_applied(), and GNUNET_PQ_load_versioning().

Here is the caller graph for this function:

check_patch_applied()

static enum GNUNET_GenericReturnValue check_patch_applied ( struct GNUNET_PQ_Context *  db, const char *  load_path, unsigned int  patch_number  )

static

Check if the patch with patch_number from the given load_path was already applied on the db.

Parameters

[in]	db	database to check
	load_path	file system path to database setup files
	patch_number	number of the patch to check

Returns

GNUNET_OK if patch is applied GNUNET_NO if patch is not applied GNUNET_SYSERR on internal error (DB failure)

Definition at line 192 of file pq_connect.c.

{
  const char *load_path_suffix;
  size_t slen = strlen (load_path) + 10;
  char patch_name[slen];
 
  if (GNUNET_SYSERR ==
      check_versioning_ok (db))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR; /* no versioning, cannot check */
  }
  load_path_suffix = strrchr (load_path,
                              '/');
  if (NULL == load_path_suffix)
    load_path_suffix = load_path;
  else
    load_path_suffix++; /* skip '/' */
  GNUNET_snprintf (patch_name,
                   sizeof (patch_name),
                   "%s%04u",
                   load_path_suffix,
                   patch_number);
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_string (patch_name),
      GNUNET_PQ_query_param_end
    };
    char *applied_by;
    struct GNUNET_PQ_ResultSpec rs[] = {
      GNUNET_PQ_result_spec_string ("applied_by",
                                    &applied_by),
      GNUNET_PQ_result_spec_end
    };
    enum GNUNET_DB_QueryStatus qs;
 
    if (GNUNET_OK !=
        prepare_check_patch (db))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                   "gnunet_pq_check_patch",
                                                   params,
                                                   rs);
    switch (qs)
    {
    case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Database version %s already applied by %s\n",
                  patch_name,
                  applied_by);
      GNUNET_PQ_cleanup_result (rs);
      return GNUNET_OK;
    case GNUNET_DB_STATUS_SUCCESS_NO_RESULTS:
      return GNUNET_NO;
    case GNUNET_DB_STATUS_SOFT_ERROR:
      GNUNET_break (0);
      return GNUNET_SYSERR;
    case GNUNET_DB_STATUS_HARD_ERROR:
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    GNUNET_assert (0);
    return GNUNET_SYSERR;
  }
}

References check_versioning_ok(), db, GNUNET_assert, GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_DB_STATUS_SOFT_ERROR, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_string(), GNUNET_snprintf(), GNUNET_SYSERR, and prepare_check_patch().

Referenced by GNUNET_PQ_check_current(), and GNUNET_PQ_run_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

pq_notice_receiver_cb()

static void pq_notice_receiver_cb ( void *  arg, const PGresult *  res  )

static

Function called by libpq whenever it wants to log something.

We already log whenever we care, so this function does nothing and merely exists to silence the libpq logging.

Parameters

arg	the SQL connection that was used
res	information about some libpq event

Definition at line 273 of file pq_connect.c.

{
  /* do nothing, intentionally */
  (void) arg;
  (void) res;
}

References res.

Referenced by GNUNET_PQ_reconnect_().

Here is the caller graph for this function:

pq_notice_processor_cb()

static void pq_notice_processor_cb ( void *  arg, const char *  message  )

static

Function called by libpq whenever it wants to log something.

We log those using the GNUnet logger.

Parameters

arg	the SQL connection that was used
message	information about some libpq event

Definition at line 290 of file pq_connect.c.

{
  (void) arg;
  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
                   "pq",
                   "%s",
                   message);
}

References GNUNET_ERROR_TYPE_INFO, and GNUNET_log_from.

Referenced by GNUNET_PQ_reconnect_().

Here is the caller graph for this function:

get_sql_file_name()

static char * get_sql_file_name ( const struct GNUNET_PQ_Context *  db, const char *  infix  )

static

Construct the name of the SQL file with the given filename infix in the load path of db.

This is the one place where the mapping from a filename infix to an actual file on disk is defined; all callers must use it, or they risk probing for files that are never loaded (and vice versa).

Parameters

db	database context to get the load path from
infix	filename infix (!) identifying the SQL file

Returns

name of the SQL file, to be freed by the caller

Definition at line 313 of file pq_connect.c.

{
  char *fn;
 
  GNUNET_asprintf (&fn,
                   "%s%s.sql",
                   db->load_path,
                   infix);
  return fn;
}

References db, and GNUNET_asprintf().

Referenced by GNUNET_PQ_exec_sql(), and patch_file_exists().

Here is the call graph for this function:

Here is the caller graph for this function:

patch_file_exists()

static enum GNUNET_GenericReturnValue patch_file_exists ( const struct GNUNET_PQ_Context *  db, const char *  load_suffix, unsigned int  patch_number  )

static

Check if the SQL file for the patch with the given patch_number exists in the load path of db.

Parameters

db	database context to get the load path from
load_suffix	suffix to append to the load path, usually "subsystem-"
patch_number	number of the patch to look for

Returns

GNUNET_YES if the file exists and is readable, GNUNET_NO if it does not exist, GNUNET_SYSERR on error

Definition at line 339 of file pq_connect.c.

{
  size_t slen = strlen (load_suffix) + 10;
  char patch_name[slen];
  char *fn;
  enum GNUNET_GenericReturnValue ret;
 
  GNUNET_snprintf (patch_name,
                   sizeof (patch_name),
                   "%s%04u",
                   load_suffix,
                   patch_number);
  fn = get_sql_file_name (db,
                          patch_name);
  ret = GNUNET_DISK_file_test_read (fn);
  GNUNET_free (fn);
  return ret;
}

References db, get_sql_file_name(), GNUNET_DISK_file_test_read(), GNUNET_free, GNUNET_snprintf(), and ret.

Referenced by find_next_patch().

Here is the call graph for this function:

Here is the caller graph for this function:

find_next_patch()

static bool find_next_patch ( const struct GNUNET_PQ_Context *  db, const char *  load_suffix, unsigned int  from, unsigned int *  found  )

static

Find the lowest patch number of at least from for which an SQL file exists in the load path of db.

Used to tell "we ran out of patches" apart from "there is a hole in the numbering": the latter must never be treated as the end of the sequence, as we would then silently ignore all patches beyond the hole.

Parameters

	db	database context to get the load path from
	load_suffix	suffix to append to the load path, usually "subsystem-"
	from	patch number to start searching at
[out]	found	set to the number of the patch that was found

Returns

true if a patch with a number of at least from exists

Definition at line 376 of file pq_connect.c.

{
  for (unsigned int i = from; i<5; i++)
  {
    if (GNUNET_YES !=
        patch_file_exists (db,
                           load_suffix,
                           i))
      continue;
    *found = i;
    return true;
  }
  return false;
}

References db, GNUNET_YES, and patch_file_exists().

Referenced by GNUNET_PQ_check_current(), and GNUNET_PQ_run_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

log_psql_output()

static void log_psql_output ( char *  output, size_t  size, bool  truncated  )

static

Log the last lines of captured psql stderr through the component logger.

Parameters

output	captured bytes, modified in place, with room for a terminator
size	number of captured bytes
truncated	whether earlier bytes have already been discarded

Definition at line 403 of file pq_connect.c.

{
  size_t start = 0;
  unsigned int lines = 0;
 
  for (size_t i = size; i > 0; i--)
  {
    /* A trailing newline terminates the last line, not an extra empty one. */
    if ( ('\n' == output[i - 1]) &&
         (i < size) &&
         (PSQL_OUTPUT_LINES == ++lines) )
    {
      start = i;
      truncated = true;
      break;
    }
  }
  if (truncated)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "psql stderr truncated to the last %u lines and %u bytes; earlier output omitted\n",
                PSQL_OUTPUT_LINES,
                PSQL_OUTPUT_BYTES);
  output[size] = '\0';
  for (size_t i = start; i < size; i++)
  {
    /* Do not let an embedded NUL hide the remaining diagnostics. */
    if ('\0' == output[i])
      output[i] = '?';
    if ('\n' != output[i])
      continue;
    output[i] = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "psql: %s\n",
                &output[start]);
    start = i + 1;
  }
  if (start < size)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "psql: %s\n",
                &output[start]);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, PSQL_OUTPUT_BYTES, PSQL_OUTPUT_LINES, size, and start.

Referenced by GNUNET_PQ_exec_sql().

Here is the caller graph for this function:

GNUNET_PQ_exec_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_exec_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	buf
	)

Execute SQL statements from buf against db.

The given filename infix in buf is prefixed with the "load_path" and ".sql" is appended to construct the full filename.

Parameters

[in,out]	db	database context to use
	buf	filename infix (!) with the SQL code to run

Returns

GNUNET_OK on success GNUNET_NO if patch buf does not exist GNUNET_SYSERR on error

Definition at line 449 of file pq_connect.c.

{
  struct GNUNET_Process *psql;
  enum GNUNET_OS_ProcessStatusType type;
  unsigned long code;
  char *fn;
  struct GNUNET_DISK_PipeHandle *errors;
  char *output;
  size_t used = 0;
  bool truncated = false;
  bool capture_failed = false;
  bool child_exited = false;
  int queued = 0;
  const struct GNUNET_DISK_FileHandle *reader;
  struct pollfd ready;
  enum GNUNET_GenericReturnValue ret = GNUNET_SYSERR;
 
  fn = get_sql_file_name (db,
                          buf);
  if (GNUNET_YES !=
      GNUNET_DISK_file_test_read (fn))
  {
    GNUNET_free (fn);
    return GNUNET_NO;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Applying SQL file `%s' on database %s\n",
              fn,
              db->config_str);
  errors = GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_WRITE);
  if (NULL == errors)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "pipe for psql stderr",
                              fn);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  output = GNUNET_malloc (PSQL_OUTPUT_BYTES + 1);
  reader = GNUNET_DISK_pipe_handle (errors,
                                    GNUNET_DISK_PIPE_END_READ);
  ready = (struct pollfd) {
    .fd = GNUNET_DISK_internal_file_handle (reader),
    .events = POLLIN
  };
  psql = GNUNET_process_create (GNUNET_OS_INHERIT_STD_NONE);
  if (GNUNET_OK !=
      GNUNET_process_set_options (
        psql,
        GNUNET_process_option_inherit_wpipe (errors,
                                             STDERR_FILENO)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to configure psql stderr capture for SQL file `%s'\n",
                fn);
    goto cleanup;
  }
  if (GNUNET_OK !=
      GNUNET_process_run_command_va (psql,
                                     "psql",
                                     "psql",
                                     db->config_str,
                                     "-f",
                                     fn,
                                     "-q",
                                     "--set",
                                     "ON_ERROR_STOP=1",
                                     NULL))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "exec",
                              "psql");
    goto cleanup;
  }
  /* Drain while psql is running so verbose scripts cannot fill the pipe.
     Descendants may inherit stderr: once psql exits, drain only the bytes
     already queued instead of waiting for every inherited writer to close. */
  while (true)
  {
    char chunk[4096];
    ssize_t count;
    size_t wanted = sizeof (chunk);
 
    if (! child_exited)
    {
      enum GNUNET_GenericReturnValue status;
 
      status = GNUNET_process_wait (psql,
                                     false,
                                     &type,
                                     &code);
      if (GNUNET_SYSERR == status)
        goto wait_failed;
      if (GNUNET_OK == status)
      {
        child_exited = true;
        while (0 > ioctl (ready.fd, FIONREAD, &queued))
        {
          if (EINTR == errno)
            continue;
          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                    "inspect queued psql stderr",
                                    fn);
          capture_failed = true;
          break;
        }
        if (capture_failed)
          break;
      }
    }
    if (child_exited)
    {
      if (0 == queued)
        break;
      wanted = GNUNET_MIN (wanted, (size_t) queued);
    }
    count = GNUNET_DISK_file_read (reader,
                                   chunk,
                                   wanted);
    if (0 == count)
      break;
    if (0 > count)
    {
      if (EINTR == errno)
        continue;
      if ( (EAGAIN == errno) || (EWOULDBLOCK == errno) )
      {
        if (child_exited)
          break;
        /* Periodically recheck the child even if an inherited writer keeps
           the pipe open without producing output. */
        if ( (0 > poll (&ready, 1, 100)) && (EINTR != errno) )
        {
          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                    "poll psql stderr",
                                    fn);
          capture_failed = true;
          break;
        }
        continue;
      }
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "read psql stderr",
                                fn);
      capture_failed = true;
      break;
    }
    if (child_exited)
      queued -= count;
    if (used + count > PSQL_OUTPUT_BYTES)
    {
      size_t discard = used + count - PSQL_OUTPUT_BYTES;
 
      memmove (output,
               output + discard,
               used - discard);
      used -= discard;
      truncated = true;
    }
    memcpy (output + used,
            chunk,
            count);
    used += count;
  }
  if (capture_failed && (! child_exited))
    (void) GNUNET_process_kill (psql,
                                SIGKILL);
  if (GNUNET_OK !=
      GNUNET_process_wait (psql,
                           true,
                           &type,
                           &code))
    goto wait_failed;
  if ( (GNUNET_OS_PROCESS_EXITED != type) ||
       (0 != code) )
  {
    if (GNUNET_OS_PROCESS_SIGNALED == type)
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to execute SQL file `%s': psql terminated by signal %lu\n",
                  fn,
                  code);
    else
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to execute SQL file `%s': psql exit code was %lu\n",
                  fn,
                  code);
    capture_failed = true;
  }
  if (capture_failed)
    log_psql_output (output,
                     used,
                     truncated);
  else
    ret = GNUNET_OK;
  goto cleanup;
wait_failed:
  /* ECHILD means another reaper already collected the process; its PID
     must not be signalled since it could have been reused. */
  {
    int eno = errno;
 
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "wait for psql",
                              fn);
    if (ECHILD != eno)
    {
      (void) GNUNET_process_kill (psql,
                                  SIGKILL);
      (void) GNUNET_process_wait (psql,
                                  true,
                                  NULL,
                                  NULL);
    }
  }
  log_psql_output (output,
                   used,
                   truncated);
cleanup:
  GNUNET_process_destroy (psql);
  GNUNET_DISK_pipe_close (errors);
  GNUNET_free (output);
  GNUNET_free (fn);
  return ret;
}

References cleanup(), db, get_sql_file_name(), GNUNET_DISK_file_read(), GNUNET_DISK_file_test_read(), GNUNET_DISK_internal_file_handle(), GNUNET_DISK_PF_BLOCKING_WRITE, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_PROCESS_EXITED, GNUNET_OS_PROCESS_SIGNALED, GNUNET_process_create(), GNUNET_process_destroy(), GNUNET_process_kill(), GNUNET_process_option_inherit_wpipe, GNUNET_process_run_command_va(), GNUNET_process_set_options, GNUNET_process_wait(), GNUNET_SYSERR, GNUNET_YES, log_psql_output(), PSQL_OUTPUT_BYTES, ret, status, and type.

Referenced by GNUNET_PQ_load_versioning(), GNUNET_PQ_run_sql(), libgnunet_plugin_datacache_postgres_done(), and namestore_postgres_drop_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_check_current()

enum GNUNET_GenericReturnValue GNUNET_PQ_check_current	(	struct GNUNET_PQ_Context *	db,
		const char *	prefix
	)

Check if the database is current with respect to database migrations using prefix.

Parameters

[in,out]	db	database to check versioning for
	prefix	prefix to use to check migrations

Returns

GNUNET_OK on success GNUNET_NO if migrations are pending GNUNET_SYSERR on failure

Definition at line 677 of file pq_connect.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Loading SQL resources from `%s'\n",
              load_suffix);
  for (unsigned int i = 1; i<10000; i++)
  {
    enum GNUNET_GenericReturnValue ret;
    unsigned int next;
 
    ret = check_patch_applied (db,
                               load_suffix,
                               i);
    if (GNUNET_SYSERR == ret)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    if (GNUNET_OK  == ret)
      continue; /* patch already applied, skip it */
    /* patch not applied, check if it (or, in case the numbering
       has a hole, any later patch) exists... */
    if (find_next_patch (db,
                         load_suffix,
                         i,
                         &next))
      return GNUNET_NO;
    return GNUNET_OK;
  }
  GNUNET_break (0); /* 10k patches applied!? */
  return GNUNET_OK;
}

References check_patch_applied(), db, find_next_patch(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and ret.

Here is the call graph for this function:

GNUNET_PQ_run_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_run_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	load_suffix
	)

Within the db context, run all the SQL files in the load path where the name starts with the load_suffix and ends with consecutive numbers from "[0000-9999].sql".

The numbering must have no gaps: if a patch file is missing but a higher-numbered one exists, this is an error, as we must not skip patches.

Parameters

db	database context to use
load_suffix	suffix to append to the load path to find the XXXX.sql files, usually "subsystem-".

Returns

GNUNET_OK on success GNUNET_NO if no upgrade was needed GNUNET_SYSERR if the upgrade failed or the patch numbering has a gap

Definition at line 713 of file pq_connect.c.

{
  size_t slen = strlen (load_suffix) + 10;
  char patch_name[slen];
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Loading SQL resources from `%s'\n",
              load_suffix);
  for (unsigned int i = 1; i<10000; i++)
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = check_patch_applied (db,
                               load_suffix,
                               i);
    if (GNUNET_SYSERR == ret)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    if (GNUNET_OK  == ret)
      continue; /* patch already applied, skip it */
 
    GNUNET_snprintf (patch_name,
                     sizeof (patch_name),
                     "%s%04u",
                     load_suffix,
                     i);
    ret = GNUNET_PQ_exec_sql (db,
                              patch_name);
    if (GNUNET_NO == ret)
    {
      unsigned int next;
 
      /* No such file.  Before we conclude that we are done, make sure
         this really is the end of the sequence and not a hole in the
         numbering: applying the patches beyond the hole (or, worse,
         silently not applying them) would leave the database in an
         undefined state. */
      if (find_next_patch (db,
                           load_suffix,
                           i + 1,
                           &next))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Gap in SQL patch sequence: `%s%04u' is missing, but `%s%04u' exists; refusing to apply patches out of order\n",
                    load_suffix,
                    i,
                    load_suffix,
                    next);
        return GNUNET_SYSERR;
      }
      break; /* no such file, we are done */
    }
    if (GNUNET_SYSERR == ret)
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References check_patch_applied(), db, find_next_patch(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_exec_sql(), GNUNET_snprintf(), GNUNET_SYSERR, and ret.

Referenced by reconnect_cb(), reconnect_setup(), reconnect_setup(), and reconnect_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_reconnect_if_down()

void GNUNET_PQ_reconnect_if_down

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db if the connection is down.

Parameters

[in,out]

db

database connection to reinitialize

Definition at line 776 of file pq_connect.c.

{
  if (1 ==
      PQconsumeInput (db->conn))
    return;
  if (CONNECTION_BAD != PQstatus (db->conn))
    return;
  GNUNET_PQ_reconnect_ (db);
}

References db, and GNUNET_PQ_reconnect_().

Here is the call graph for this function:

GNUNET_PQ_get_oid_by_name()

enum GNUNET_GenericReturnValue GNUNET_PQ_get_oid_by_name	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		Oid *	oid
	)

Returns the oid for a given datatype by name.

Parameters

	db	The db-connection
	name	The name of the datatype
[out]	oid	The OID of the datatype.

Returns

GNUNET_OK when the datatype was found, GNUNET_SYSERR otherwise

Definition at line 788 of file pq_connect.c.

{
  /* Check if the entry is in the cache already */
  for (unsigned int i = 0; i < db->oids.num; i++)
  {
    /* Pointer comparison */
    if (name == db->oids.table[i].name)
    {
      *oid = db->oids.table[i].oid;
      return GNUNET_OK;
    }
  }
 
  /* No entry found in cache, ask database */
  {
    enum GNUNET_DB_QueryStatus qs;
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_string (name),
      GNUNET_PQ_query_param_end
    };
    struct GNUNET_PQ_ResultSpec spec[] = {
      GNUNET_PQ_result_spec_uint32 ("oid",
                                    oid),
      GNUNET_PQ_result_spec_end
    };
 
    GNUNET_assert (NULL != db);
 
    qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                   "gnunet_pq_get_oid_by_name",
                                                   params,
                                                   spec);
    if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
      return GNUNET_SYSERR;
  }
 
  /* Add the entry to the cache */
  if (NULL == db->oids.table)
  {
    db->oids.table = GNUNET_new_array (8,
                                       typeof(*db->oids.table));
    db->oids.cap = 8;
    db->oids.num = 0;
  }
 
  if (db->oids.cap <= db->oids.num)
    GNUNET_array_grow (db->oids.table,
                       db->oids.cap,
                       db->oids.cap + 8);
 
  db->oids.table[db->oids.num].name = name;
  db->oids.table[db->oids.num].oid = *oid;
  db->oids.num++;
 
  return GNUNET_OK;
}

References db, GNUNET_array_grow, GNUNET_assert, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_new_array, GNUNET_OK, GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_SYSERR, name, and oid.

Referenced by GNUNET_PQ_query_param_array_abs_time(), GNUNET_PQ_query_param_array_bool(), GNUNET_PQ_query_param_array_bytes(), GNUNET_PQ_query_param_array_bytes_same_size(), GNUNET_PQ_query_param_array_int16(), GNUNET_PQ_query_param_array_ptrs_abs_time(), GNUNET_PQ_query_param_array_ptrs_bytes(), GNUNET_PQ_query_param_array_ptrs_bytes_same_size(), GNUNET_PQ_query_param_array_ptrs_rel_time(), GNUNET_PQ_query_param_array_ptrs_string(), GNUNET_PQ_query_param_array_ptrs_timestamp(), GNUNET_PQ_query_param_array_rel_time(), GNUNET_PQ_query_param_array_string(), GNUNET_PQ_query_param_array_timestamp(), GNUNET_PQ_query_param_array_uint16(), GNUNET_PQ_query_param_array_uint32(), GNUNET_PQ_query_param_array_uint64(), GNUNET_PQ_result_spec_array_abs_time(), GNUNET_PQ_result_spec_array_bool(), GNUNET_PQ_result_spec_array_fixed_size(), GNUNET_PQ_result_spec_array_int16(), GNUNET_PQ_result_spec_array_rel_time(), GNUNET_PQ_result_spec_array_string(), GNUNET_PQ_result_spec_array_timestamp(), GNUNET_PQ_result_spec_array_uint16(), GNUNET_PQ_result_spec_array_uint32(), GNUNET_PQ_result_spec_array_uint64(), GNUNET_PQ_result_spec_array_variable_size(), and load_initial_oids().

Here is the call graph for this function:

Here is the caller graph for this function:

load_initial_oids()

static enum GNUNET_GenericReturnValue load_initial_oids ( struct GNUNET_PQ_Context *  db )

static

Load the initial set of OIDs for the supported array-datatypes.

Parameters

db	The database context

Returns

GNUNET_OK on success, GNUNET_SYSERR if any of the types couldn't be found

Definition at line 858 of file pq_connect.c.

{
  static const char *typnames[] = {
    "bool",
    "int2",
    "int4",
    "int8",
    "bytea",
    "varchar"
  };
  Oid oid;
 
  for (size_t i = 0; i< sizeof(typnames) / sizeof(*typnames); i++)
  {
    if (GNUNET_OK !=
        GNUNET_PQ_get_oid_by_name (db,
                                   typnames[i],
                                   &oid))
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                       "pq",
                       "Couldn't retrieve OID for type %s\n",
                       typnames[i]);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_SYSERR, and oid.

Referenced by GNUNET_PQ_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_reconnect_()

void GNUNET_PQ_reconnect_

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db.

Parameters

db	database connection to reinitialize

Deprecated:

Definition at line 889 of file pq_connect.c.

{
  GNUNET_PQ_event_reconnect_ (db,
                              -1);
  reset_connection (db);
  db->versioning_ok = GNUNET_SYSERR; /* new connection, new game */
  db->conn = PQconnectdb (db->config_str);
  if ( (NULL == db->conn) ||
       (CONNECTION_OK != PQstatus (db->conn)) )
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Database connection to '%s' failed: %s\n",
                     db->config_str,
                     (NULL != db->conn)
                     ? PQerrorMessage (db->conn)
                     : "PQconnectdb returned NULL");
    reset_connection (db);
    return;
  }
  PQsetNoticeReceiver (db->conn,
                       &pq_notice_receiver_cb,
                       db);
  PQsetNoticeProcessor (db->conn,
                        &pq_notice_processor_cb,
                        db);
  if (NULL != db->rc)
    db->rc (db->rc_cls,
            db);
 
  /* Prepare statement for OID lookup by name */
  if (GNUNET_OK !=
      prepare_get_oid_by_name (db))
    return;
 
  /* Reset the OID-cache and retrieve the OIDs for the supported Array types */
  db->oids.num = 0;
  if (GNUNET_SYSERR == load_initial_oids (db))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to retrieve OID information for array types!\n");
    reset_connection (db);
    return;
  }
  GNUNET_PQ_event_reconnect_ (db,
                              PQsocket (db->conn));
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_event_reconnect_(), GNUNET_SYSERR, load_initial_oids(), pq_notice_processor_cb(), pq_notice_receiver_cb(), prepare_get_oid_by_name(), and reset_connection().

Referenced by do_scheduler_notify(), GNUNET_PQ_eval_result(), GNUNET_PQ_event_do_poll(), GNUNET_PQ_exec_prepared(), GNUNET_PQ_init(), and GNUNET_PQ_reconnect_if_down().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_load_versioning()

enum GNUNET_GenericReturnValue GNUNET_PQ_load_versioning

(

struct GNUNET_PQ_Context *

db

)

Setup database versioning.

Parameters

[in,out]

db

database to load versioning for

Returns

GNUNET_OK on success GNUNET_NO if it was already loaded GNUNET_SYSERR on failure

Definition at line 939 of file pq_connect.c.

{
  enum GNUNET_GenericReturnValue ret;
 
  ret = check_versioning_ok (db);
  if (GNUNET_SYSERR == ret)
    return GNUNET_SYSERR;
  if (GNUNET_YES == ret)
    return GNUNET_NO; /* already setup */
  ret = GNUNET_PQ_exec_sql (db,
                            "versioning");
  if (GNUNET_NO == ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to find SQL file to load database versioning logic\n");
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL logic to setup database versioning logic\n");
    return GNUNET_SYSERR;
  }
  db->versioning_ok = GNUNET_YES;
  return GNUNET_OK;
}

References check_versioning_ok(), db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_exec_sql(), GNUNET_SYSERR, GNUNET_YES, and ret.

Referenced by reconnect_setup(), and reconnect_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_init()

struct GNUNET_PQ_Context * GNUNET_PQ_init	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		GNUNET_PQ_ReconnectCallback	rc,
		GNUNET_PQ_RECONNECT_CALLBACK_CLOSURE *	rc_cls
	)

Definition at line 968 of file pq_connect.c.

{
  struct GNUNET_PQ_Context *db;
  char *conninfo;
  char *load_path;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "CONFIG",
                                             &conninfo))
    conninfo = GNUNET_strdup ("");
  load_path = NULL;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               section,
                                               "SQL_DIR",
                                               &load_path))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               section,
                               "SQL_DIR");
  }
  db = GNUNET_new (struct GNUNET_PQ_Context);
  db->versioning_ok = GNUNET_SYSERR;
  db->config_str = conninfo;
  db->load_path = load_path;
  db->rc = rc;
  db->rc_cls = rc_cls;
  db->channel_map = GNUNET_CONTAINER_multishortmap_create (16,
                                                           true);
  GNUNET_PQ_reconnect_ (db);
  if (NULL == db->conn)
  {
    GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
    GNUNET_free (db->config_str);
    GNUNET_free (db);
    return NULL;
  }
  return db;
}

References cfg, db, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, GNUNET_PQ_reconnect_(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_PQ_Context::load_path, GNUNET_PQ_Context::rc, and GNUNET_PQ_Context::rc_cls.

Here is the call graph for this function:

GNUNET_PQ_disconnect()

void GNUNET_PQ_disconnect

(

struct GNUNET_PQ_Context *

db

)

Disconnect from the database, destroying the prepared statements and releasing other associated resources.

Parameters

db	database handle to disconnect (will be free'd)

Definition at line 1015 of file pq_connect.c.

{
  if (NULL == db)
    return;
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multishortmap_size (db->channel_map));
  GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
  if (NULL != db->poller_task)
  {
    GNUNET_SCHEDULER_cancel (db->poller_task);
    db->poller_task = NULL;
  }
  GNUNET_free (db->load_path);
  GNUNET_free (db->config_str);
  GNUNET_free (db->oids.table);
  db->oids.num = 0;
  db->oids.cap = 0;
  PQfinish (db->conn);
  GNUNET_free (db);
}

References db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_free, and GNUNET_SCHEDULER_cancel().

Referenced by database_shutdown(), database_shutdown(), libgnunet_plugin_datacache_postgres_done(), libgnunet_plugin_datastore_postgres_done(), namestore_postgres_create_tables(), and namestore_postgres_drop_tables().

Here is the call graph for this function:

Here is the caller graph for this function: