LCOV - code coverage report
Current view: top level - src/bin/pg_upgrade - server.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 100 125 80.0 %
Date: 2025-07-29 03:18:01 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  *  server.c
       3             :  *
       4             :  *  database server functions
       5             :  *
       6             :  *  Copyright (c) 2010-2025, PostgreSQL Global Development Group
       7             :  *  src/bin/pg_upgrade/server.c
       8             :  */
       9             : 
      10             : #include "postgres_fe.h"
      11             : 
      12             : #include "common/connect.h"
      13             : #include "fe_utils/string_utils.h"
      14             : #include "libpq/pqcomm.h"
      15             : #include "pg_upgrade.h"
      16             : 
      17             : static PGconn *get_db_conn(ClusterInfo *cluster, const char *db_name);
      18             : 
      19             : 
      20             : /*
      21             :  * connectToServer()
      22             :  *
      23             :  *  Connects to the desired database on the designated server.
      24             :  *  If the connection attempt fails, this function logs an error
      25             :  *  message and calls exit() to kill the program.
      26             :  */
      27             : PGconn *
      28         534 : connectToServer(ClusterInfo *cluster, const char *db_name)
      29             : {
      30         534 :     PGconn     *conn = get_db_conn(cluster, db_name);
      31             : 
      32         534 :     if (conn == NULL || PQstatus(conn) != CONNECTION_OK)
      33             :     {
      34           0 :         pg_log(PG_REPORT, "%s", PQerrorMessage(conn));
      35             : 
      36           0 :         if (conn)
      37           0 :             PQfinish(conn);
      38             : 
      39           0 :         printf(_("Failure, exiting\n"));
      40           0 :         exit(1);
      41             :     }
      42             : 
      43         534 :     PQclear(executeQueryOrDie(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));
      44             : 
      45         534 :     return conn;
      46             : }
      47             : 
      48             : 
      49             : /*
      50             :  * get_db_conn()
      51             :  *
      52             :  * get database connection, using named database + standard params for cluster
      53             :  *
      54             :  * Caller must check for connection failure!
      55             :  */
      56             : static PGconn *
      57         628 : get_db_conn(ClusterInfo *cluster, const char *db_name)
      58             : {
      59             :     PQExpBufferData conn_opts;
      60             :     PGconn     *conn;
      61             : 
      62             :     /* Build connection string with proper quoting */
      63         628 :     initPQExpBuffer(&conn_opts);
      64         628 :     appendPQExpBufferStr(&conn_opts, "dbname=");
      65         628 :     appendConnStrVal(&conn_opts, db_name);
      66         628 :     appendPQExpBufferStr(&conn_opts, " user=");
      67         628 :     appendConnStrVal(&conn_opts, os_info.user);
      68         628 :     appendPQExpBuffer(&conn_opts, " port=%d", cluster->port);
      69         628 :     if (cluster->sockdir)
      70             :     {
      71         628 :         appendPQExpBufferStr(&conn_opts, " host=");
      72         628 :         appendConnStrVal(&conn_opts, cluster->sockdir);
      73             :     }
      74             : 
      75         628 :     conn = PQconnectdb(conn_opts.data);
      76         628 :     termPQExpBuffer(&conn_opts);
      77         628 :     return conn;
      78             : }
      79             : 
      80             : 
      81             : /*
      82             :  * cluster_conn_opts()
      83             :  *
      84             :  * Return standard command-line options for connecting to this cluster when
      85             :  * using psql, pg_dump, etc.  Ideally this would match what get_db_conn()
      86             :  * sets, but the utilities we need aren't very consistent about the treatment
      87             :  * of database name options, so we leave that out.
      88             :  *
      89             :  * Result is valid until the next call to this function.
      90             :  */
      91             : char *
      92         174 : cluster_conn_opts(ClusterInfo *cluster)
      93             : {
      94             :     static PQExpBuffer buf;
      95             : 
      96         174 :     if (buf == NULL)
      97          20 :         buf = createPQExpBuffer();
      98             :     else
      99         154 :         resetPQExpBuffer(buf);
     100             : 
     101         174 :     if (cluster->sockdir)
     102             :     {
     103         174 :         appendPQExpBufferStr(buf, "--host ");
     104         174 :         appendShellString(buf, cluster->sockdir);
     105         174 :         appendPQExpBufferChar(buf, ' ');
     106             :     }
     107         174 :     appendPQExpBuffer(buf, "--port %d --username ", cluster->port);
     108         174 :     appendShellString(buf, os_info.user);
     109             : 
     110         174 :     return buf->data;
     111             : }
     112             : 
     113             : 
     114             : /*
     115             :  * executeQueryOrDie()
     116             :  *
     117             :  *  Formats a query string from the given arguments and executes the
     118             :  *  resulting query.  If the query fails, this function logs an error
     119             :  *  message and calls exit() to kill the program.
     120             :  */
     121             : PGresult *
     122        1216 : executeQueryOrDie(PGconn *conn, const char *fmt,...)
     123             : {
     124             :     static char query[QUERY_ALLOC];
     125             :     va_list     args;
     126             :     PGresult   *result;
     127             :     ExecStatusType status;
     128             : 
     129        1216 :     va_start(args, fmt);
     130        1216 :     vsnprintf(query, sizeof(query), fmt, args);
     131        1216 :     va_end(args);
     132             : 
     133        1216 :     pg_log(PG_VERBOSE, "executing: %s", query);
     134        1216 :     result = PQexec(conn, query);
     135        1216 :     status = PQresultStatus(result);
     136             : 
     137        1216 :     if ((status != PGRES_TUPLES_OK) && (status != PGRES_COMMAND_OK))
     138             :     {
     139           0 :         pg_log(PG_REPORT, "SQL command failed\n%s\n%s", query,
     140             :                PQerrorMessage(conn));
     141           0 :         PQclear(result);
     142           0 :         PQfinish(conn);
     143           0 :         printf(_("Failure, exiting\n"));
     144           0 :         exit(1);
     145             :     }
     146             :     else
     147        1216 :         return result;
     148             : }
     149             : 
     150             : 
     151             : /*
     152             :  * get_major_server_version()
     153             :  *
     154             :  * gets the version (in unsigned int form) for the given datadir. Assumes
     155             :  * that datadir is an absolute path to a valid pgdata directory. The version
     156             :  * is retrieved by reading the PG_VERSION file.
     157             :  */
     158             : uint32
     159          68 : get_major_server_version(ClusterInfo *cluster)
     160             : {
     161             :     FILE       *version_fd;
     162             :     char        ver_filename[MAXPGPATH];
     163          68 :     int         v1 = 0,
     164          68 :                 v2 = 0;
     165             : 
     166          68 :     snprintf(ver_filename, sizeof(ver_filename), "%s/PG_VERSION",
     167             :              cluster->pgdata);
     168          68 :     if ((version_fd = fopen(ver_filename, "r")) == NULL)
     169           0 :         pg_fatal("could not open version file \"%s\": %m", ver_filename);
     170             : 
     171          68 :     if (fscanf(version_fd, "%63s", cluster->major_version_str) == 0 ||
     172          68 :         sscanf(cluster->major_version_str, "%d.%d", &v1, &v2) < 1)
     173           0 :         pg_fatal("could not parse version file \"%s\"", ver_filename);
     174             : 
     175          68 :     fclose(version_fd);
     176             : 
     177          68 :     if (v1 < 10)
     178             :     {
     179             :         /* old style, e.g. 9.6.1 */
     180           0 :         return v1 * 10000 + v2 * 100;
     181             :     }
     182             :     else
     183             :     {
     184             :         /* new style, e.g. 10.1 */
     185          68 :         return v1 * 10000;
     186             :     }
     187             : }
     188             : 
     189             : 
     190             : static void
     191          32 : stop_postmaster_atexit(void)
     192             : {
     193          32 :     stop_postmaster(true);
     194          32 : }
     195             : 
     196             : 
     197             : bool
     198          94 : start_postmaster(ClusterInfo *cluster, bool report_and_exit_on_error)
     199             : {
     200             :     char        cmd[MAXPGPATH * 4 + 1000];
     201             :     PGconn     *conn;
     202          94 :     bool        pg_ctl_return = false;
     203             :     char        socket_string[MAXPGPATH + 200];
     204             :     PQExpBufferData pgoptions;
     205             : 
     206             :     static bool exit_hook_registered = false;
     207             : 
     208          94 :     if (!exit_hook_registered)
     209             :     {
     210          32 :         atexit(stop_postmaster_atexit);
     211          32 :         exit_hook_registered = true;
     212             :     }
     213             : 
     214          94 :     socket_string[0] = '\0';
     215             : 
     216             : #if !defined(WIN32)
     217             :     /* prevent TCP/IP connections, restrict socket access */
     218          94 :     strcat(socket_string,
     219             :            " -c listen_addresses='' -c unix_socket_permissions=0700");
     220             : 
     221             :     /* Have a sockdir?  Tell the postmaster. */
     222          94 :     if (cluster->sockdir)
     223          94 :         snprintf(socket_string + strlen(socket_string),
     224          94 :                  sizeof(socket_string) - strlen(socket_string),
     225             :                  " -c %s='%s'",
     226          94 :                  (GET_MAJOR_VERSION(cluster->major_version) <= 902) ?
     227             :                  "unix_socket_directory" : "unix_socket_directories",
     228             :                  cluster->sockdir);
     229             : #endif
     230             : 
     231          94 :     initPQExpBuffer(&pgoptions);
     232             : 
     233             :     /*
     234             :      * Construct a parameter string which is passed to the server process.
     235             :      *
     236             :      * Turn off durability requirements to improve object creation speed, and
     237             :      * we only modify the new cluster, so only use it there.  If there is a
     238             :      * crash, the new cluster has to be recreated anyway.  fsync=off is a big
     239             :      * win on ext4.
     240             :      */
     241          94 :     if (cluster == &new_cluster)
     242          62 :         appendPQExpBufferStr(&pgoptions, " -c synchronous_commit=off -c fsync=off -c full_page_writes=off");
     243             : 
     244             :     /*
     245             :      * Use -b to disable autovacuum and logical replication launcher
     246             :      * (effective in PG17 or later for the latter).
     247             :      */
     248          94 :     snprintf(cmd, sizeof(cmd),
     249             :              "\"%s/pg_ctl\" -w -l \"%s/%s\" -D \"%s\" -o \"-p %d -b%s %s%s\" start",
     250             :              cluster->bindir,
     251             :              log_opts.logdir,
     252          94 :              SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
     253             :              pgoptions.data,
     254          94 :              cluster->pgopts ? cluster->pgopts : "", socket_string);
     255             : 
     256          94 :     termPQExpBuffer(&pgoptions);
     257             : 
     258             :     /*
     259             :      * Don't throw an error right away, let connecting throw the error because
     260             :      * it might supply a reason for the failure.
     261             :      */
     262          94 :     pg_ctl_return = exec_prog(SERVER_START_LOG_FILE,
     263             :     /* pass both file names if they differ */
     264             :                               (strcmp(SERVER_LOG_FILE,
     265             :                                       SERVER_START_LOG_FILE) != 0) ?
     266             :                               SERVER_LOG_FILE : NULL,
     267             :                               report_and_exit_on_error, false,
     268             :                               "%s", cmd);
     269             : 
     270             :     /* Did it fail and we are just testing if the server could be started? */
     271          94 :     if (!pg_ctl_return && !report_and_exit_on_error)
     272           0 :         return false;
     273             : 
     274             :     /*
     275             :      * We set this here to make sure atexit() shuts down the server, but only
     276             :      * if we started the server successfully.  We do it before checking for
     277             :      * connectivity in case the server started but there is a connectivity
     278             :      * failure.  If pg_ctl did not return success, we will exit below.
     279             :      *
     280             :      * Pre-9.1 servers do not have PQping(), so we could be leaving the server
     281             :      * running if authentication was misconfigured, so someday we might went
     282             :      * to be more aggressive about doing server shutdowns even if pg_ctl
     283             :      * fails, but now (2013-08-14) it seems prudent to be cautious.  We don't
     284             :      * want to shutdown a server that might have been accidentally started
     285             :      * during the upgrade.
     286             :      */
     287          94 :     if (pg_ctl_return)
     288          94 :         os_info.running_cluster = cluster;
     289             : 
     290             :     /*
     291             :      * pg_ctl -w might have failed because the server couldn't be started, or
     292             :      * there might have been a connection problem in _checking_ if the server
     293             :      * has started.  Therefore, even if pg_ctl failed, we continue and test
     294             :      * for connectivity in case we get a connection reason for the failure.
     295             :      */
     296         188 :     if ((conn = get_db_conn(cluster, "template1")) == NULL ||
     297          94 :         PQstatus(conn) != CONNECTION_OK)
     298             :     {
     299           0 :         pg_log(PG_REPORT, "\n%s", PQerrorMessage(conn));
     300           0 :         if (conn)
     301           0 :             PQfinish(conn);
     302           0 :         if (cluster == &old_cluster)
     303           0 :             pg_fatal("could not connect to source postmaster started with the command:\n"
     304             :                      "%s",
     305             :                      cmd);
     306             :         else
     307           0 :             pg_fatal("could not connect to target postmaster started with the command:\n"
     308             :                      "%s",
     309             :                      cmd);
     310             :     }
     311          94 :     PQfinish(conn);
     312             : 
     313             :     /*
     314             :      * If pg_ctl failed, and the connection didn't fail, and
     315             :      * report_and_exit_on_error is enabled, fail now.  This could happen if
     316             :      * the server was already running.
     317             :      */
     318          94 :     if (!pg_ctl_return)
     319             :     {
     320           0 :         if (cluster == &old_cluster)
     321           0 :             pg_fatal("pg_ctl failed to start the source server, or connection failed");
     322             :         else
     323           0 :             pg_fatal("pg_ctl failed to start the target server, or connection failed");
     324             :     }
     325             : 
     326          94 :     return true;
     327             : }
     328             : 
     329             : 
     330             : void
     331         112 : stop_postmaster(bool in_atexit)
     332             : {
     333             :     ClusterInfo *cluster;
     334             : 
     335         112 :     if (os_info.running_cluster == &old_cluster)
     336          32 :         cluster = &old_cluster;
     337          80 :     else if (os_info.running_cluster == &new_cluster)
     338          62 :         cluster = &new_cluster;
     339             :     else
     340          18 :         return;                 /* no cluster running */
     341             : 
     342         188 :     exec_prog(SERVER_STOP_LOG_FILE, NULL, !in_atexit, !in_atexit,
     343             :               "\"%s/pg_ctl\" -w -D \"%s\" -o \"%s\" %s stop",
     344             :               cluster->bindir, cluster->pgconfig,
     345          94 :               cluster->pgopts ? cluster->pgopts : "",
     346          94 :               in_atexit ? "-m fast" : "-m smart");
     347             : 
     348          94 :     os_info.running_cluster = NULL;
     349             : }
     350             : 
     351             : 
     352             : /*
     353             :  * check_pghost_envvar()
     354             :  *
     355             :  * Tests that PGHOST does not point to a non-local server
     356             :  */
     357             : void
     358          36 : check_pghost_envvar(void)
     359             : {
     360             :     PQconninfoOption *option;
     361             :     PQconninfoOption *start;
     362             : 
     363             :     /* Get valid libpq env vars from the PQconndefaults function */
     364             : 
     365          36 :     start = PQconndefaults();
     366             : 
     367          36 :     if (!start)
     368           0 :         pg_fatal("out of memory");
     369             : 
     370        1872 :     for (option = start; option->keyword != NULL; option++)
     371             :     {
     372        1836 :         if (option->envvar && (strcmp(option->envvar, "PGHOST") == 0 ||
     373        1260 :                                strcmp(option->envvar, "PGHOSTADDR") == 0))
     374             :         {
     375          72 :             const char *value = getenv(option->envvar);
     376             : 
     377          72 :             if (value && strlen(value) > 0 &&
     378             :             /* check for 'local' host values */
     379          36 :                 (strcmp(value, "localhost") != 0 && strcmp(value, "127.0.0.1") != 0 &&
     380          36 :                  strcmp(value, "::1") != 0 && !is_unixsock_path(value)))
     381           0 :                 pg_fatal("libpq environment variable %s has a non-local server value: %s",
     382             :                          option->envvar, value);
     383             :         }
     384             :     }
     385             : 
     386             :     /* Free the memory that libpq allocated on our behalf */
     387          36 :     PQconninfoFree(start);
     388          36 : }

Generated by: LCOV version 1.16