/*-------------------------------------------------------------------------
 *
 * connectdb.c
 *    This is a common file connection to the database.
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/bin/pg_dump/connectdb.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres_fe.h"

#include "common/connect.h"
#include "common/logging.h"
#include "common/string.h"
#include "connectdb.h"
#include "dumputils.h"
#include "fe_utils/string_utils.h"

static char *constructConnStr(const char **keywords, const char **values);

/*
 * ConnectDatabase
 *
 * Make a database connection with the given parameters.  An
 * interactive password prompt is automatically issued if required.
 *
 * If fail_on_error is false, we return NULL without printing any message
 * on failure, but preserve any prompted password for the next try.
 *
 * On success, the 'connstr' is set to a connection string containing
 * the options used and 'server_version' is set to version so that caller
 * can use them.
 */
PGconn *
ConnectDatabase(const char *dbname, const char *connection_string,
    const char *pghost, const char *pgport, const char *pguser,
    trivalue prompt_password, bool fail_on_error, const char *progname,
    const char **connstr, int *server_version, char *password,
    char *override_dbname)
{
 PGconn    *conn;
 bool  new_pass;
 const char *remoteversion_str;
 int   my_version;
 const char **keywords = NULL;
 const char **values = NULL;
 PQconninfoOption *conn_opts = NULL;
 int   server_version_temp;

 if (prompt_password == TRI_YES && !password)
  password = simple_prompt("Password: ", false);

 /*
  * Start the connection.  Loop until we have a password if requested by
  * backend.
 */
 do
 {
  int   argcount = 8;
  PQconninfoOption *conn_opt;
  char    *err_msg = NULL;
  int   i = 0;

  free(keywords);
  free(values);
  PQconninfoFree(conn_opts);

  /*
   * Merge the connection info inputs given in form of connection string
   * and other options.  Explicitly discard any dbname value in the
   * connection string; otherwise, PQconnectdbParams() would interpret
   * that value as being itself a connection string.
 */
  if (connection_string)
  {
   conn_opts = PQconninfoParse(connection_string, &err_msg);
   if (conn_opts == NULL)
    pg_fatal("%s", err_msg);

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

   keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
   values = pg_malloc0((argcount + 1) * sizeof(*values));

   for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
   {
    if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
     strcmp(conn_opt->keyword, "dbname") != 0)
    {
     keywords[i] = conn_opt->keyword;
     values[i] = conn_opt->val;
     i++;
    }
   }
  }
  else
  {
   keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
   values = pg_malloc0((argcount + 1) * sizeof(*values));
  }

  if (pghost)
  {
   keywords[i] = "host";
   values[i] = pghost;
   i++;
  }
  if (pgport)
  {
   keywords[i] = "port";
   values[i] = pgport;
   i++;
  }
  if (pguser)
  {
   keywords[i] = "user";
   values[i] = pguser;
   i++;
  }
  if (password)
  {
   keywords[i] = "password";
   values[i] = password;
   i++;
  }
  if (dbname)
  {
   keywords[i] = "dbname";
   values[i] = dbname;
   i++;
  }
  if (override_dbname)
  {
   keywords[i] = "dbname";
   values[i] = override_dbname;
   i++;
  }

  keywords[i] = "fallback_application_name";
  values[i] = progname;
  i++;

  new_pass = false;
  conn = PQconnectdbParams(keywords, values, true);

  if (!conn)
   pg_fatal("could not connect to database \"%s\"", dbname);

  if (PQstatus(conn) == CONNECTION_BAD &&
   PQconnectionNeedsPassword(conn) &&
   !password &&
   prompt_password != TRI_NO)
  {
   PQfinish(conn);
   password = simple_prompt("Password: ", false);
   new_pass = true;
  }
 } while (new_pass);

 /* check to see that the backend connection was successfully made */
 if (PQstatus(conn) == CONNECTION_BAD)
 {
  if (fail_on_error)
   pg_fatal("%s", PQerrorMessage(conn));
  else
  {
   PQfinish(conn);

   free(keywords);
   free(values);
   PQconninfoFree(conn_opts);

   return NULL;
  }
 }

 /*
  * Ok, connected successfully. If requested, remember the options used, in
  * the form of a connection string.
 */
 if (connstr)
  *connstr = constructConnStr(keywords, values);

 free(keywords);
 free(values);
 PQconninfoFree(conn_opts);

 /* Check version */
 remoteversion_str = PQparameterStatus(conn, "server_version");
 if (!remoteversion_str)
  pg_fatal("could not get server version");

 server_version_temp = PQserverVersion(conn);
 if (server_version_temp == 0)
  pg_fatal("could not parse server version \"%s\"",
     remoteversion_str);

 /* If requested, then copy server version to out variable. */
 if (server_version)
  *server_version = server_version_temp;

 my_version = PG_VERSION_NUM;

 /*
  * We allow the server to be back to 9.2, and up to any minor release of
  * our own major version.  (See also version check in pg_dump.c.)
 */
 if (my_version != server_version_temp
  && (server_version_temp < 90200 ||
   (server_version_temp / 100) > (my_version / 100)))
 {
  pg_log_error("aborting because of server version mismatch");
  pg_log_error_detail("server version: %s; %s version: %s",
       remoteversion_str, progname, PG_VERSION);
  exit_nicely(1);
 }

 PQclear(executeQuery(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));

 return conn;
}

/*
 * constructConnStr
 *
 * Construct a connection string from the given keyword/value pairs. It is
 * used to pass the connection options to the pg_dump subprocess.
 *
 * The following parameters are excluded:
 * dbname  - varies in each pg_dump invocation
 * password - it's not secure to pass a password on the command line
 * fallback_application_name - we'll let pg_dump set it
 */
static char *
constructConnStr(const char **keywords, const char **values)
{
 PQExpBuffer buf = createPQExpBuffer();
 char    *connstr;
 int   i;
 bool  firstkeyword = true;

 /* Construct a new connection string in key='value' format. */
 for (i = 0; keywords[i] != NULL; i++)
 {
  if (strcmp(keywords[i], "dbname") == 0 ||
   strcmp(keywords[i], "password") == 0 ||
   strcmp(keywords[i], "fallback_application_name") == 0)
   continue;

  if (!firstkeyword)
   appendPQExpBufferChar(buf, ' ');
  firstkeyword = false;
  appendPQExpBuffer(buf, "%s=", keywords[i]);
  appendConnStrVal(buf, values[i]);
 }

 connstr = pg_strdup(buf->data);
 destroyPQExpBuffer(buf);
 return connstr;
}

/*
 * executeQuery
 *
 * Run a query, return the results, exit program on failure.
 */
PGresult *
executeQuery(PGconn *conn, const char *query)
{
 PGresult   *res;

 pg_log_info("executing %s", query);

 res = PQexec(conn, query);
 if (!res ||
  PQresultStatus(res) != PGRES_TUPLES_OK)
 {
  pg_log_error("query failed: %s", PQerrorMessage(conn));
  pg_log_error_detail("Query was: %s", query);
  PQfinish(conn);
  exit_nicely(1);
 }

 return res;
}