LCOV - code coverage report
Current view: top level - src/bin/pg_dump - pg_dumpall.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 493 752 65.6 %
Date: 2019-11-21 14:06:36 Functions: 17 19 89.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_dumpall.c
       4             :  *
       5             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       6             :  * Portions Copyright (c) 1994, Regents of the University of California
       7             :  *
       8             :  * pg_dumpall forces all pg_dump output to be text, since it also outputs
       9             :  * text into the same output stream.
      10             :  *
      11             :  * src/bin/pg_dump/pg_dumpall.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : 
      16             : #include "postgres_fe.h"
      17             : 
      18             : #include <time.h>
      19             : #include <unistd.h>
      20             : 
      21             : #include "common/file_utils.h"
      22             : #include "common/logging.h"
      23             : #include "dumputils.h"
      24             : #include "fe_utils/connect.h"
      25             : #include "fe_utils/string_utils.h"
      26             : #include "getopt_long.h"
      27             : #include "pg_backup.h"
      28             : 
      29             : /* version string we expect back from pg_dump */
      30             : #define PGDUMP_VERSIONSTR "pg_dump (PostgreSQL) " PG_VERSION "\n"
      31             : 
      32             : 
      33             : static void help(void);
      34             : 
      35             : static void dropRoles(PGconn *conn);
      36             : static void dumpRoles(PGconn *conn);
      37             : static void dumpRoleMembership(PGconn *conn);
      38             : static void dumpGroups(PGconn *conn);
      39             : static void dropTablespaces(PGconn *conn);
      40             : static void dumpTablespaces(PGconn *conn);
      41             : static void dropDBs(PGconn *conn);
      42             : static void dumpUserConfig(PGconn *conn, const char *username);
      43             : static void dumpDatabases(PGconn *conn);
      44             : static void dumpTimestamp(const char *msg);
      45             : static int  runPgDump(const char *dbname, const char *create_opts);
      46             : static void buildShSecLabels(PGconn *conn,
      47             :                              const char *catalog_name, Oid objectId,
      48             :                              const char *objtype, const char *objname,
      49             :                              PQExpBuffer buffer);
      50             : static PGconn *connectDatabase(const char *dbname, const char *connstr, const char *pghost, const char *pgport,
      51             :                                const char *pguser, trivalue prompt_password, bool fail_on_error);
      52             : static char *constructConnStr(const char **keywords, const char **values);
      53             : static PGresult *executeQuery(PGconn *conn, const char *query);
      54             : static void executeCommand(PGconn *conn, const char *query);
      55             : static void expand_dbname_patterns(PGconn *conn, SimpleStringList *patterns,
      56             :                                    SimpleStringList *names);
      57             : 
      58             : static char pg_dump_bin[MAXPGPATH];
      59             : static const char *progname;
      60             : static PQExpBuffer pgdumpopts;
      61             : static char *connstr = "";
      62             : static bool output_clean = false;
      63             : static bool skip_acls = false;
      64             : static bool verbose = false;
      65             : static bool dosync = true;
      66             : 
      67             : static int  binary_upgrade = 0;
      68             : static int  column_inserts = 0;
      69             : static int  disable_dollar_quoting = 0;
      70             : static int  disable_triggers = 0;
      71             : static int  if_exists = 0;
      72             : static int  inserts = 0;
      73             : static int  no_tablespaces = 0;
      74             : static int  use_setsessauth = 0;
      75             : static int  no_comments = 0;
      76             : static int  no_publications = 0;
      77             : static int  no_security_labels = 0;
      78             : static int  no_subscriptions = 0;
      79             : static int  no_unlogged_table_data = 0;
      80             : static int  no_role_passwords = 0;
      81             : static int  server_version;
      82             : static int  load_via_partition_root = 0;
      83             : static int  on_conflict_do_nothing = 0;
      84             : 
      85             : static char role_catalog[10];
      86             : #define PG_AUTHID "pg_authid"
      87             : #define PG_ROLES  "pg_roles "
      88             : 
      89             : static FILE *OPF;
      90             : static char *filename = NULL;
      91             : 
      92             : static SimpleStringList database_exclude_patterns = {NULL, NULL};
      93             : static SimpleStringList database_exclude_names = {NULL, NULL};
      94             : 
      95             : #define exit_nicely(code) exit(code)
      96             : 
      97             : int
      98          48 : main(int argc, char *argv[])
      99             : {
     100             :     static struct option long_options[] = {
     101             :         {"data-only", no_argument, NULL, 'a'},
     102             :         {"clean", no_argument, NULL, 'c'},
     103             :         {"encoding", required_argument, NULL, 'E'},
     104             :         {"file", required_argument, NULL, 'f'},
     105             :         {"globals-only", no_argument, NULL, 'g'},
     106             :         {"host", required_argument, NULL, 'h'},
     107             :         {"dbname", required_argument, NULL, 'd'},
     108             :         {"database", required_argument, NULL, 'l'},
     109             :         {"no-owner", no_argument, NULL, 'O'},
     110             :         {"port", required_argument, NULL, 'p'},
     111             :         {"roles-only", no_argument, NULL, 'r'},
     112             :         {"schema-only", no_argument, NULL, 's'},
     113             :         {"superuser", required_argument, NULL, 'S'},
     114             :         {"tablespaces-only", no_argument, NULL, 't'},
     115             :         {"username", required_argument, NULL, 'U'},
     116             :         {"verbose", no_argument, NULL, 'v'},
     117             :         {"no-password", no_argument, NULL, 'w'},
     118             :         {"password", no_argument, NULL, 'W'},
     119             :         {"no-privileges", no_argument, NULL, 'x'},
     120             :         {"no-acl", no_argument, NULL, 'x'},
     121             : 
     122             :         /*
     123             :          * the following options don't have an equivalent short option letter
     124             :          */
     125             :         {"attribute-inserts", no_argument, &column_inserts, 1},
     126             :         {"binary-upgrade", no_argument, &binary_upgrade, 1},
     127             :         {"column-inserts", no_argument, &column_inserts, 1},
     128             :         {"disable-dollar-quoting", no_argument, &disable_dollar_quoting, 1},
     129             :         {"disable-triggers", no_argument, &disable_triggers, 1},
     130             :         {"exclude-database", required_argument, NULL, 6},
     131             :         {"extra-float-digits", required_argument, NULL, 5},
     132             :         {"if-exists", no_argument, &if_exists, 1},
     133             :         {"inserts", no_argument, &inserts, 1},
     134             :         {"lock-wait-timeout", required_argument, NULL, 2},
     135             :         {"no-tablespaces", no_argument, &no_tablespaces, 1},
     136             :         {"quote-all-identifiers", no_argument, &quote_all_identifiers, 1},
     137             :         {"load-via-partition-root", no_argument, &load_via_partition_root, 1},
     138             :         {"role", required_argument, NULL, 3},
     139             :         {"use-set-session-authorization", no_argument, &use_setsessauth, 1},
     140             :         {"no-comments", no_argument, &no_comments, 1},
     141             :         {"no-publications", no_argument, &no_publications, 1},
     142             :         {"no-role-passwords", no_argument, &no_role_passwords, 1},
     143             :         {"no-security-labels", no_argument, &no_security_labels, 1},
     144             :         {"no-subscriptions", no_argument, &no_subscriptions, 1},
     145             :         {"no-sync", no_argument, NULL, 4},
     146             :         {"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},
     147             :         {"on-conflict-do-nothing", no_argument, &on_conflict_do_nothing, 1},
     148             :         {"rows-per-insert", required_argument, NULL, 7},
     149             : 
     150             :         {NULL, 0, NULL, 0}
     151             :     };
     152             : 
     153          48 :     char       *pghost = NULL;
     154          48 :     char       *pgport = NULL;
     155          48 :     char       *pguser = NULL;
     156          48 :     char       *pgdb = NULL;
     157          48 :     char       *use_role = NULL;
     158          48 :     const char *dumpencoding = NULL;
     159          48 :     trivalue    prompt_password = TRI_DEFAULT;
     160          48 :     bool        data_only = false;
     161          48 :     bool        globals_only = false;
     162          48 :     bool        roles_only = false;
     163          48 :     bool        tablespaces_only = false;
     164             :     PGconn     *conn;
     165             :     int         encoding;
     166             :     const char *std_strings;
     167             :     int         c,
     168             :                 ret;
     169             :     int         optindex;
     170             : 
     171          48 :     pg_logging_init(argv[0]);
     172          48 :     pg_logging_set_level(PG_LOG_WARNING);
     173          48 :     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));
     174          48 :     progname = get_progname(argv[0]);
     175             : 
     176          48 :     if (argc > 1)
     177             :     {
     178          48 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
     179             :         {
     180           2 :             help();
     181           2 :             exit_nicely(0);
     182             :         }
     183          46 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
     184             :         {
     185           2 :             puts("pg_dumpall (PostgreSQL) " PG_VERSION);
     186           2 :             exit_nicely(0);
     187             :         }
     188             :     }
     189             : 
     190          44 :     if ((ret = find_other_exec(argv[0], "pg_dump", PGDUMP_VERSIONSTR,
     191             :                                pg_dump_bin)) < 0)
     192             :     {
     193             :         char        full_path[MAXPGPATH];
     194             : 
     195           0 :         if (find_my_exec(argv[0], full_path) < 0)
     196           0 :             strlcpy(full_path, progname, sizeof(full_path));
     197             : 
     198           0 :         if (ret == -1)
     199           0 :             pg_log_error("The program \"pg_dump\" is needed by %s but was not found in the\n"
     200             :                          "same directory as \"%s\".\n"
     201             :                          "Check your installation.",
     202             :                          progname, full_path);
     203             :         else
     204           0 :             pg_log_error("The program \"pg_dump\" was found by \"%s\"\n"
     205             :                          "but was not the same version as %s.\n"
     206             :                          "Check your installation.",
     207             :                          full_path, progname);
     208           0 :         exit_nicely(1);
     209             :     }
     210             : 
     211          44 :     pgdumpopts = createPQExpBuffer();
     212             : 
     213         220 :     while ((c = getopt_long(argc, argv, "acd:E:f:gh:l:Op:rsS:tU:vwWx", long_options, &optindex)) != -1)
     214             :     {
     215         134 :         switch (c)
     216             :         {
     217             :             case 'a':
     218           0 :                 data_only = true;
     219           0 :                 appendPQExpBufferStr(pgdumpopts, " -a");
     220           0 :                 break;
     221             : 
     222             :             case 'c':
     223           2 :                 output_clean = true;
     224           2 :                 break;
     225             : 
     226             :             case 'd':
     227           8 :                 connstr = pg_strdup(optarg);
     228           8 :                 break;
     229             : 
     230             :             case 'E':
     231           0 :                 dumpencoding = pg_strdup(optarg);
     232           0 :                 appendPQExpBufferStr(pgdumpopts, " -E ");
     233           0 :                 appendShellString(pgdumpopts, optarg);
     234           0 :                 break;
     235             : 
     236             :             case 'f':
     237          28 :                 filename = pg_strdup(optarg);
     238          28 :                 appendPQExpBufferStr(pgdumpopts, " -f ");
     239          28 :                 appendShellString(pgdumpopts, filename);
     240          28 :                 break;
     241             : 
     242             :             case 'g':
     243          14 :                 globals_only = true;
     244          14 :                 break;
     245             : 
     246             :             case 'h':
     247           2 :                 pghost = pg_strdup(optarg);
     248           2 :                 break;
     249             : 
     250             :             case 'l':
     251           2 :                 pgdb = pg_strdup(optarg);
     252           2 :                 break;
     253             : 
     254             :             case 'O':
     255           0 :                 appendPQExpBufferStr(pgdumpopts, " -O");
     256           0 :                 break;
     257             : 
     258             :             case 'p':
     259           2 :                 pgport = pg_strdup(optarg);
     260           2 :                 break;
     261             : 
     262             :             case 'r':
     263          14 :                 roles_only = true;
     264          14 :                 break;
     265             : 
     266             :             case 's':
     267           0 :                 appendPQExpBufferStr(pgdumpopts, " -s");
     268           0 :                 break;
     269             : 
     270             :             case 'S':
     271           0 :                 appendPQExpBufferStr(pgdumpopts, " -S ");
     272           0 :                 appendShellString(pgdumpopts, optarg);
     273           0 :                 break;
     274             : 
     275             :             case 't':
     276           4 :                 tablespaces_only = true;
     277           4 :                 break;
     278             : 
     279             :             case 'U':
     280          16 :                 pguser = pg_strdup(optarg);
     281          16 :                 break;
     282             : 
     283             :             case 'v':
     284           4 :                 verbose = true;
     285           4 :                 pg_logging_set_level(PG_LOG_INFO);
     286           4 :                 appendPQExpBufferStr(pgdumpopts, " -v");
     287           4 :                 break;
     288             : 
     289             :             case 'w':
     290           0 :                 prompt_password = TRI_NO;
     291           0 :                 appendPQExpBufferStr(pgdumpopts, " -w");
     292           0 :                 break;
     293             : 
     294             :             case 'W':
     295           0 :                 prompt_password = TRI_YES;
     296           0 :                 appendPQExpBufferStr(pgdumpopts, " -W");
     297           0 :                 break;
     298             : 
     299             :             case 'x':
     300           0 :                 skip_acls = true;
     301           0 :                 appendPQExpBufferStr(pgdumpopts, " -x");
     302           0 :                 break;
     303             : 
     304             :             case 0:
     305           6 :                 break;
     306             : 
     307             :             case 2:
     308           0 :                 appendPQExpBufferStr(pgdumpopts, " --lock-wait-timeout ");
     309           0 :                 appendShellString(pgdumpopts, optarg);
     310           0 :                 break;
     311             : 
     312             :             case 3:
     313           0 :                 use_role = pg_strdup(optarg);
     314           0 :                 appendPQExpBufferStr(pgdumpopts, " --role ");
     315           0 :                 appendShellString(pgdumpopts, use_role);
     316           0 :                 break;
     317             : 
     318             :             case 4:
     319          26 :                 dosync = false;
     320          26 :                 appendPQExpBufferStr(pgdumpopts, " --no-sync");
     321          26 :                 break;
     322             : 
     323             :             case 5:
     324           0 :                 appendPQExpBufferStr(pgdumpopts, " --extra-float-digits ");
     325           0 :                 appendShellString(pgdumpopts, optarg);
     326           0 :                 break;
     327             : 
     328             :             case 6:
     329           4 :                 simple_string_list_append(&database_exclude_patterns, optarg);
     330           4 :                 break;
     331             : 
     332             :             case 7:
     333           0 :                 appendPQExpBufferStr(pgdumpopts, " --rows-per-insert ");
     334           0 :                 appendShellString(pgdumpopts, optarg);
     335           0 :                 break;
     336             : 
     337             :             default:
     338           2 :                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
     339           2 :                 exit_nicely(1);
     340             :         }
     341             :     }
     342             : 
     343             :     /* Complain if any arguments remain */
     344          42 :     if (optind < argc)
     345             :     {
     346           2 :         pg_log_error("too many command-line arguments (first is \"%s\")",
     347             :                      argv[optind]);
     348           2 :         fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     349             :                 progname);
     350           2 :         exit_nicely(1);
     351             :     }
     352             : 
     353          40 :     if (database_exclude_patterns.head != NULL &&
     354           2 :         (globals_only || roles_only || tablespaces_only))
     355             :     {
     356           2 :         pg_log_error("option --exclude-database cannot be used together with -g/--globals-only, -r/--roles-only, or -t/--tablespaces-only");
     357           2 :         fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     358             :                 progname);
     359           2 :         exit_nicely(1);
     360             :     }
     361             : 
     362             :     /* Make sure the user hasn't specified a mix of globals-only options */
     363          38 :     if (globals_only && roles_only)
     364             :     {
     365           2 :         pg_log_error("options -g/--globals-only and -r/--roles-only cannot be used together");
     366           2 :         fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     367             :                 progname);
     368           2 :         exit_nicely(1);
     369             :     }
     370             : 
     371          36 :     if (globals_only && tablespaces_only)
     372             :     {
     373           2 :         pg_log_error("options -g/--globals-only and -t/--tablespaces-only cannot be used together");
     374           2 :         fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     375             :                 progname);
     376           2 :         exit_nicely(1);
     377             :     }
     378             : 
     379          34 :     if (if_exists && !output_clean)
     380             :     {
     381           2 :         pg_log_error("option --if-exists requires option -c/--clean");
     382           2 :         exit_nicely(1);
     383             :     }
     384             : 
     385          32 :     if (roles_only && tablespaces_only)
     386             :     {
     387           2 :         pg_log_error("options -r/--roles-only and -t/--tablespaces-only cannot be used together");
     388           2 :         fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     389             :                 progname);
     390           2 :         exit_nicely(1);
     391             :     }
     392             : 
     393             :     /*
     394             :      * If password values are not required in the dump, switch to using
     395             :      * pg_roles which is equally useful, just more likely to have unrestricted
     396             :      * access than pg_authid.
     397             :      */
     398          30 :     if (no_role_passwords)
     399           0 :         sprintf(role_catalog, "%s", PG_ROLES);
     400             :     else
     401          30 :         sprintf(role_catalog, "%s", PG_AUTHID);
     402             : 
     403             :     /* Add long options to the pg_dump argument list */
     404          30 :     if (binary_upgrade)
     405           2 :         appendPQExpBufferStr(pgdumpopts, " --binary-upgrade");
     406          30 :     if (column_inserts)
     407           0 :         appendPQExpBufferStr(pgdumpopts, " --column-inserts");
     408          30 :     if (disable_dollar_quoting)
     409           0 :         appendPQExpBufferStr(pgdumpopts, " --disable-dollar-quoting");
     410          30 :     if (disable_triggers)
     411           0 :         appendPQExpBufferStr(pgdumpopts, " --disable-triggers");
     412          30 :     if (inserts)
     413           0 :         appendPQExpBufferStr(pgdumpopts, " --inserts");
     414          30 :     if (no_tablespaces)
     415           0 :         appendPQExpBufferStr(pgdumpopts, " --no-tablespaces");
     416          30 :     if (quote_all_identifiers)
     417           2 :         appendPQExpBufferStr(pgdumpopts, " --quote-all-identifiers");
     418          30 :     if (load_via_partition_root)
     419           0 :         appendPQExpBufferStr(pgdumpopts, " --load-via-partition-root");
     420          30 :     if (use_setsessauth)
     421           0 :         appendPQExpBufferStr(pgdumpopts, " --use-set-session-authorization");
     422          30 :     if (no_comments)
     423           0 :         appendPQExpBufferStr(pgdumpopts, " --no-comments");
     424          30 :     if (no_publications)
     425           0 :         appendPQExpBufferStr(pgdumpopts, " --no-publications");
     426          30 :     if (no_security_labels)
     427           0 :         appendPQExpBufferStr(pgdumpopts, " --no-security-labels");
     428          30 :     if (no_subscriptions)
     429           0 :         appendPQExpBufferStr(pgdumpopts, " --no-subscriptions");
     430          30 :     if (no_unlogged_table_data)
     431           0 :         appendPQExpBufferStr(pgdumpopts, " --no-unlogged-table-data");
     432          30 :     if (on_conflict_do_nothing)
     433           0 :         appendPQExpBufferStr(pgdumpopts, " --on-conflict-do-nothing");
     434             : 
     435             :     /*
     436             :      * If there was a database specified on the command line, use that,
     437             :      * otherwise try to connect to database "postgres", and failing that
     438             :      * "template1".  "postgres" is the preferred choice for 8.1 and later
     439             :      * servers, but it usually will not exist on older ones.
     440             :      */
     441          30 :     if (pgdb)
     442             :     {
     443           2 :         conn = connectDatabase(pgdb, connstr, pghost, pgport, pguser,
     444             :                                prompt_password, false);
     445             : 
     446           2 :         if (!conn)
     447             :         {
     448           0 :             pg_log_error("could not connect to database \"%s\"", pgdb);
     449           0 :             exit_nicely(1);
     450             :         }
     451             :     }
     452             :     else
     453             :     {
     454          28 :         conn = connectDatabase("postgres", connstr, pghost, pgport, pguser,
     455             :                                prompt_password, false);
     456          28 :         if (!conn)
     457           0 :             conn = connectDatabase("template1", connstr, pghost, pgport, pguser,
     458             :                                    prompt_password, true);
     459             : 
     460          28 :         if (!conn)
     461             :         {
     462           0 :             pg_log_error("could not connect to databases \"postgres\" or \"template1\"\n"
     463             :                          "Please specify an alternative database.");
     464           0 :             fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
     465             :                     progname);
     466           0 :             exit_nicely(1);
     467             :         }
     468             :     }
     469             : 
     470             :     /*
     471             :      * Get a list of database names that match the exclude patterns
     472             :      */
     473          30 :     expand_dbname_patterns(conn, &database_exclude_patterns,
     474             :                            &database_exclude_names);
     475             : 
     476             :     /*
     477             :      * Open the output file if required, otherwise use stdout
     478             :      */
     479          30 :     if (filename)
     480             :     {
     481          28 :         OPF = fopen(filename, PG_BINARY_W);
     482          28 :         if (!OPF)
     483             :         {
     484           0 :             pg_log_error("could not open output file \"%s\": %m",
     485             :                          filename);
     486           0 :             exit_nicely(1);
     487             :         }
     488             :     }
     489             :     else
     490           2 :         OPF = stdout;
     491             : 
     492             :     /*
     493             :      * Set the client encoding if requested.
     494             :      */
     495          30 :     if (dumpencoding)
     496             :     {
     497           0 :         if (PQsetClientEncoding(conn, dumpencoding) < 0)
     498             :         {
     499           0 :             pg_log_error("invalid client encoding \"%s\" specified",
     500             :                          dumpencoding);
     501           0 :             exit_nicely(1);
     502             :         }
     503             :     }
     504             : 
     505             :     /*
     506             :      * Get the active encoding and the standard_conforming_strings setting, so
     507             :      * we know how to escape strings.
     508             :      */
     509          30 :     encoding = PQclientEncoding(conn);
     510          30 :     std_strings = PQparameterStatus(conn, "standard_conforming_strings");
     511          30 :     if (!std_strings)
     512           0 :         std_strings = "off";
     513             : 
     514             :     /* Set the role if requested */
     515          30 :     if (use_role && server_version >= 80100)
     516             :     {
     517           0 :         PQExpBuffer query = createPQExpBuffer();
     518             : 
     519           0 :         appendPQExpBuffer(query, "SET ROLE %s", fmtId(use_role));
     520           0 :         executeCommand(conn, query->data);
     521           0 :         destroyPQExpBuffer(query);
     522             :     }
     523             : 
     524             :     /* Force quoting of all identifiers if requested. */
     525          30 :     if (quote_all_identifiers && server_version >= 90100)
     526           2 :         executeCommand(conn, "SET quote_all_identifiers = true");
     527             : 
     528          30 :     fprintf(OPF, "--\n-- PostgreSQL database cluster dump\n--\n\n");
     529          30 :     if (verbose)
     530           4 :         dumpTimestamp("Started on");
     531             : 
     532             :     /*
     533             :      * We used to emit \connect postgres here, but that served no purpose
     534             :      * other than to break things for installations without a postgres
     535             :      * database.  Everything we're restoring here is a global, so whichever
     536             :      * database we're connected to at the moment is fine.
     537             :      */
     538             : 
     539             :     /* Restore will need to write to the target cluster */
     540          30 :     fprintf(OPF, "SET default_transaction_read_only = off;\n\n");
     541             : 
     542             :     /* Replicate encoding and std_strings in output */
     543          30 :     fprintf(OPF, "SET client_encoding = '%s';\n",
     544             :             pg_encoding_to_char(encoding));
     545          30 :     fprintf(OPF, "SET standard_conforming_strings = %s;\n", std_strings);
     546          30 :     if (strcmp(std_strings, "off") == 0)
     547           0 :         fprintf(OPF, "SET escape_string_warning = off;\n");
     548          30 :     fprintf(OPF, "\n");
     549             : 
     550          30 :     if (!data_only)
     551             :     {
     552             :         /*
     553             :          * If asked to --clean, do that first.  We can avoid detailed
     554             :          * dependency analysis because databases never depend on each other,
     555             :          * and tablespaces never depend on each other.  Roles could have
     556             :          * grants to each other, but DROP ROLE will clean those up silently.
     557             :          */
     558          30 :         if (output_clean)
     559             :         {
     560           2 :             if (!globals_only && !roles_only && !tablespaces_only)
     561           0 :                 dropDBs(conn);
     562             : 
     563           2 :             if (!roles_only && !no_tablespaces)
     564           2 :                 dropTablespaces(conn);
     565             : 
     566           2 :             if (!tablespaces_only)
     567           2 :                 dropRoles(conn);
     568             :         }
     569             : 
     570             :         /*
     571             :          * Now create objects as requested.  Be careful that option logic here
     572             :          * is the same as for drops above.
     573             :          */
     574          30 :         if (!tablespaces_only)
     575             :         {
     576             :             /* Dump roles (users) */
     577          30 :             dumpRoles(conn);
     578             : 
     579             :             /* Dump role memberships --- need different method for pre-8.1 */
     580          30 :             if (server_version >= 80100)
     581          30 :                 dumpRoleMembership(conn);
     582             :             else
     583           0 :                 dumpGroups(conn);
     584             :         }
     585             : 
     586             :         /* Dump tablespaces */
     587          30 :         if (!roles_only && !no_tablespaces)
     588          20 :             dumpTablespaces(conn);
     589             :     }
     590             : 
     591          30 :     if (!globals_only && !roles_only && !tablespaces_only)
     592          12 :         dumpDatabases(conn);
     593             : 
     594          28 :     PQfinish(conn);
     595             : 
     596          28 :     if (verbose)
     597           4 :         dumpTimestamp("Completed on");
     598          28 :     fprintf(OPF, "--\n-- PostgreSQL database cluster dump complete\n--\n\n");
     599             : 
     600          28 :     if (filename)
     601             :     {
     602          26 :         fclose(OPF);
     603             : 
     604             :         /* sync the resulting file, errors are not fatal */
     605          26 :         if (dosync)
     606           4 :             (void) fsync_fname(filename, false);
     607             :     }
     608             : 
     609          28 :     exit_nicely(0);
     610             : }
     611             : 
     612             : 
     613             : static void
     614           2 : help(void)
     615             : {
     616           2 :     printf(_("%s extracts a PostgreSQL database cluster into an SQL script file.\n\n"), progname);
     617           2 :     printf(_("Usage:\n"));
     618           2 :     printf(_("  %s [OPTION]...\n"), progname);
     619             : 
     620           2 :     printf(_("\nGeneral options:\n"));
     621           2 :     printf(_("  -f, --file=FILENAME          output file name\n"));
     622           2 :     printf(_("  -v, --verbose                verbose mode\n"));
     623           2 :     printf(_("  -V, --version                output version information, then exit\n"));
     624           2 :     printf(_("  --lock-wait-timeout=TIMEOUT  fail after waiting TIMEOUT for a table lock\n"));
     625           2 :     printf(_("  -?, --help                   show this help, then exit\n"));
     626           2 :     printf(_("\nOptions controlling the output content:\n"));
     627           2 :     printf(_("  -a, --data-only              dump only the data, not the schema\n"));
     628           2 :     printf(_("  -c, --clean                  clean (drop) databases before recreating\n"));
     629           2 :     printf(_("  -E, --encoding=ENCODING      dump the data in encoding ENCODING\n"));
     630           2 :     printf(_("  -g, --globals-only           dump only global objects, no databases\n"));
     631           2 :     printf(_("  -O, --no-owner               skip restoration of object ownership\n"));
     632           2 :     printf(_("  -r, --roles-only             dump only roles, no databases or tablespaces\n"));
     633           2 :     printf(_("  -s, --schema-only            dump only the schema, no data\n"));
     634           2 :     printf(_("  -S, --superuser=NAME         superuser user name to use in the dump\n"));
     635           2 :     printf(_("  -t, --tablespaces-only       dump only tablespaces, no databases or roles\n"));
     636           2 :     printf(_("  -x, --no-privileges          do not dump privileges (grant/revoke)\n"));
     637           2 :     printf(_("  --binary-upgrade             for use by upgrade utilities only\n"));
     638           2 :     printf(_("  --column-inserts             dump data as INSERT commands with column names\n"));
     639           2 :     printf(_("  --disable-dollar-quoting     disable dollar quoting, use SQL standard quoting\n"));
     640           2 :     printf(_("  --disable-triggers           disable triggers during data-only restore\n"));
     641           2 :     printf(_("  --exclude-database=PATTERN   exclude databases whose name matches PATTERN\n"));
     642           2 :     printf(_("  --extra-float-digits=NUM     override default setting for extra_float_digits\n"));
     643           2 :     printf(_("  --if-exists                  use IF EXISTS when dropping objects\n"));
     644           2 :     printf(_("  --inserts                    dump data as INSERT commands, rather than COPY\n"));
     645           2 :     printf(_("  --load-via-partition-root    load partitions via the root table\n"));
     646           2 :     printf(_("  --no-comments                do not dump comments\n"));
     647           2 :     printf(_("  --no-publications            do not dump publications\n"));
     648           2 :     printf(_("  --no-role-passwords          do not dump passwords for roles\n"));
     649           2 :     printf(_("  --no-security-labels         do not dump security label assignments\n"));
     650           2 :     printf(_("  --no-subscriptions           do not dump subscriptions\n"));
     651           2 :     printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
     652           2 :     printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
     653           2 :     printf(_("  --no-unlogged-table-data     do not dump unlogged table data\n"));
     654           2 :     printf(_("  --on-conflict-do-nothing     add ON CONFLICT DO NOTHING to INSERT commands\n"));
     655           2 :     printf(_("  --quote-all-identifiers      quote all identifiers, even if not key words\n"));
     656           2 :     printf(_("  --rows-per-insert=NROWS      number of rows per INSERT; implies --inserts\n"));
     657           2 :     printf(_("  --use-set-session-authorization\n"
     658             :              "                               use SET SESSION AUTHORIZATION commands instead of\n"
     659             :              "                               ALTER OWNER commands to set ownership\n"));
     660             : 
     661           2 :     printf(_("\nConnection options:\n"));
     662           2 :     printf(_("  -d, --dbname=CONNSTR     connect using connection string\n"));
     663           2 :     printf(_("  -h, --host=HOSTNAME      database server host or socket directory\n"));
     664           2 :     printf(_("  -l, --database=DBNAME    alternative default database\n"));
     665           2 :     printf(_("  -p, --port=PORT          database server port number\n"));
     666           2 :     printf(_("  -U, --username=NAME      connect as specified database user\n"));
     667           2 :     printf(_("  -w, --no-password        never prompt for password\n"));
     668           2 :     printf(_("  -W, --password           force password prompt (should happen automatically)\n"));
     669           2 :     printf(_("  --role=ROLENAME          do SET ROLE before dump\n"));
     670             : 
     671           2 :     printf(_("\nIf -f/--file is not used, then the SQL script will be written to the standard\n"
     672             :              "output.\n\n"));
     673           2 :     printf(_("Report bugs to <pgsql-bugs@lists.postgresql.org>.\n"));
     674           2 : }
     675             : 
     676             : 
     677             : /*
     678             :  * Drop roles
     679             :  */
     680             : static void
     681           2 : dropRoles(PGconn *conn)
     682             : {
     683           2 :     PQExpBuffer buf = createPQExpBuffer();
     684             :     PGresult   *res;
     685             :     int         i_rolname;
     686             :     int         i;
     687             : 
     688           2 :     if (server_version >= 90600)
     689           2 :         printfPQExpBuffer(buf,
     690             :                           "SELECT rolname "
     691             :                           "FROM %s "
     692             :                           "WHERE rolname !~ '^pg_' "
     693             :                           "ORDER BY 1", role_catalog);
     694           0 :     else if (server_version >= 80100)
     695           0 :         printfPQExpBuffer(buf,
     696             :                           "SELECT rolname "
     697             :                           "FROM %s "
     698             :                           "ORDER BY 1", role_catalog);
     699             :     else
     700           0 :         printfPQExpBuffer(buf,
     701             :                           "SELECT usename as rolname "
     702             :                           "FROM pg_shadow "
     703             :                           "UNION "
     704             :                           "SELECT groname as rolname "
     705             :                           "FROM pg_group "
     706             :                           "ORDER BY 1");
     707             : 
     708           2 :     res = executeQuery(conn, buf->data);
     709             : 
     710           2 :     i_rolname = PQfnumber(res, "rolname");
     711             : 
     712           2 :     if (PQntuples(res) > 0)
     713           2 :         fprintf(OPF, "--\n-- Drop roles\n--\n\n");
     714             : 
     715           6 :     for (i = 0; i < PQntuples(res); i++)
     716             :     {
     717             :         const char *rolename;
     718             : 
     719           4 :         rolename = PQgetvalue(res, i, i_rolname);
     720             : 
     721           8 :         fprintf(OPF, "DROP ROLE %s%s;\n",
     722           4 :                 if_exists ? "IF EXISTS " : "",
     723             :                 fmtId(rolename));
     724             :     }
     725             : 
     726           2 :     PQclear(res);
     727           2 :     destroyPQExpBuffer(buf);
     728             : 
     729           2 :     fprintf(OPF, "\n\n");
     730           2 : }
     731             : 
     732             : /*
     733             :  * Dump roles
     734             :  */
     735             : static void
     736          30 : dumpRoles(PGconn *conn)
     737             : {
     738          30 :     PQExpBuffer buf = createPQExpBuffer();
     739             :     PGresult   *res;
     740             :     int         i_oid,
     741             :                 i_rolname,
     742             :                 i_rolsuper,
     743             :                 i_rolinherit,
     744             :                 i_rolcreaterole,
     745             :                 i_rolcreatedb,
     746             :                 i_rolcanlogin,
     747             :                 i_rolconnlimit,
     748             :                 i_rolpassword,
     749             :                 i_rolvaliduntil,
     750             :                 i_rolreplication,
     751             :                 i_rolbypassrls,
     752             :                 i_rolcomment,
     753             :                 i_is_current_user;
     754             :     int         i;
     755             : 
     756             :     /* note: rolconfig is dumped later */
     757          30 :     if (server_version >= 90600)
     758          30 :         printfPQExpBuffer(buf,
     759             :                           "SELECT oid, rolname, rolsuper, rolinherit, "
     760             :                           "rolcreaterole, rolcreatedb, "
     761             :                           "rolcanlogin, rolconnlimit, rolpassword, "
     762             :                           "rolvaliduntil, rolreplication, rolbypassrls, "
     763             :                           "pg_catalog.shobj_description(oid, '%s') as rolcomment, "
     764             :                           "rolname = current_user AS is_current_user "
     765             :                           "FROM %s "
     766             :                           "WHERE rolname !~ '^pg_' "
     767             :                           "ORDER BY 2", role_catalog, role_catalog);
     768           0 :     else if (server_version >= 90500)
     769           0 :         printfPQExpBuffer(buf,
     770             :                           "SELECT oid, rolname, rolsuper, rolinherit, "
     771             :                           "rolcreaterole, rolcreatedb, "
     772             :                           "rolcanlogin, rolconnlimit, rolpassword, "
     773             :                           "rolvaliduntil, rolreplication, rolbypassrls, "
     774             :                           "pg_catalog.shobj_description(oid, '%s') as rolcomment, "
     775             :                           "rolname = current_user AS is_current_user "
     776             :                           "FROM %s "
     777             :                           "ORDER BY 2", role_catalog, role_catalog);
     778           0 :     else if (server_version >= 90100)
     779           0 :         printfPQExpBuffer(buf,
     780             :                           "SELECT oid, rolname, rolsuper, rolinherit, "
     781             :                           "rolcreaterole, rolcreatedb, "
     782             :                           "rolcanlogin, rolconnlimit, rolpassword, "
     783             :                           "rolvaliduntil, rolreplication, "
     784             :                           "false as rolbypassrls, "
     785             :                           "pg_catalog.shobj_description(oid, '%s') as rolcomment, "
     786             :                           "rolname = current_user AS is_current_user "
     787             :                           "FROM %s "
     788             :                           "ORDER BY 2", role_catalog, role_catalog);
     789           0 :     else if (server_version >= 80200)
     790           0 :         printfPQExpBuffer(buf,
     791             :                           "SELECT oid, rolname, rolsuper, rolinherit, "
     792             :                           "rolcreaterole, rolcreatedb, "
     793             :                           "rolcanlogin, rolconnlimit, rolpassword, "
     794             :                           "rolvaliduntil, false as rolreplication, "
     795             :                           "false as rolbypassrls, "
     796             :                           "pg_catalog.shobj_description(oid, '%s') as rolcomment, "
     797             :                           "rolname = current_user AS is_current_user "
     798             :                           "FROM %s "
     799             :                           "ORDER BY 2", role_catalog, role_catalog);
     800           0 :     else if (server_version >= 80100)
     801           0 :         printfPQExpBuffer(buf,
     802             :                           "SELECT oid, rolname, rolsuper, rolinherit, "
     803             :                           "rolcreaterole, rolcreatedb, "
     804             :                           "rolcanlogin, rolconnlimit, rolpassword, "
     805             :                           "rolvaliduntil, false as rolreplication, "
     806             :                           "false as rolbypassrls, "
     807             :                           "null as rolcomment, "
     808             :                           "rolname = current_user AS is_current_user "
     809             :                           "FROM %s "
     810             :                           "ORDER BY 2", role_catalog);
     811             :     else
     812           0 :         printfPQExpBuffer(buf,
     813             :                           "SELECT 0 as oid, usename as rolname, "
     814             :                           "usesuper as rolsuper, "
     815             :                           "true as rolinherit, "
     816             :                           "usesuper as rolcreaterole, "
     817             :                           "usecreatedb as rolcreatedb, "
     818             :                           "true as rolcanlogin, "
     819             :                           "-1 as rolconnlimit, "
     820             :                           "passwd as rolpassword, "
     821             :                           "valuntil as rolvaliduntil, "
     822             :                           "false as rolreplication, "
     823             :                           "false as rolbypassrls, "
     824             :                           "null as rolcomment, "
     825             :                           "usename = current_user AS is_current_user "
     826             :                           "FROM pg_shadow "
     827             :                           "UNION ALL "
     828             :                           "SELECT 0 as oid, groname as rolname, "
     829             :                           "false as rolsuper, "
     830             :                           "true as rolinherit, "
     831             :                           "false as rolcreaterole, "
     832             :                           "false as rolcreatedb, "
     833             :                           "false as rolcanlogin, "
     834             :                           "-1 as rolconnlimit, "
     835             :                           "null::text as rolpassword, "
     836             :                           "null::timestamptz as rolvaliduntil, "
     837             :                           "false as rolreplication, "
     838             :                           "false as rolbypassrls, "
     839             :                           "null as rolcomment, "
     840             :                           "false AS is_current_user "
     841             :                           "FROM pg_group "
     842             :                           "WHERE NOT EXISTS (SELECT 1 FROM pg_shadow "
     843             :                           " WHERE usename = groname) "
     844             :                           "ORDER BY 2");
     845             : 
     846          30 :     res = executeQuery(conn, buf->data);
     847             : 
     848          30 :     i_oid = PQfnumber(res, "oid");
     849          30 :     i_rolname = PQfnumber(res, "rolname");
     850          30 :     i_rolsuper = PQfnumber(res, "rolsuper");
     851          30 :     i_rolinherit = PQfnumber(res, "rolinherit");
     852          30 :     i_rolcreaterole = PQfnumber(res, "rolcreaterole");
     853          30 :     i_rolcreatedb = PQfnumber(res, "rolcreatedb");
     854          30 :     i_rolcanlogin = PQfnumber(res, "rolcanlogin");
     855          30 :     i_rolconnlimit = PQfnumber(res, "rolconnlimit");
     856          30 :     i_rolpassword = PQfnumber(res, "rolpassword");
     857          30 :     i_rolvaliduntil = PQfnumber(res, "rolvaliduntil");
     858          30 :     i_rolreplication = PQfnumber(res, "rolreplication");
     859          30 :     i_rolbypassrls = PQfnumber(res, "rolbypassrls");
     860          30 :     i_rolcomment = PQfnumber(res, "rolcomment");
     861          30 :     i_is_current_user = PQfnumber(res, "is_current_user");
     862             : 
     863          30 :     if (PQntuples(res) > 0)
     864          30 :         fprintf(OPF, "--\n-- Roles\n--\n\n");
     865             : 
     866         126 :     for (i = 0; i < PQntuples(res); i++)
     867             :     {
     868             :         const char *rolename;
     869             :         Oid         auth_oid;
     870             : 
     871          96 :         auth_oid = atooid(PQgetvalue(res, i, i_oid));
     872          96 :         rolename = PQgetvalue(res, i, i_rolname);
     873             : 
     874          96 :         if (strncmp(rolename, "pg_", 3) == 0)
     875             :         {
     876           0 :             pg_log_warning("role name starting with \"pg_\" skipped (%s)",
     877             :                            rolename);
     878           0 :             continue;
     879             :         }
     880             : 
     881          96 :         resetPQExpBuffer(buf);
     882             : 
     883          96 :         if (binary_upgrade)
     884             :         {
     885           2 :             appendPQExpBufferStr(buf, "\n-- For binary upgrade, must preserve pg_authid.oid\n");
     886           2 :             appendPQExpBuffer(buf,
     887             :                               "SELECT pg_catalog.binary_upgrade_set_next_pg_authid_oid('%u'::pg_catalog.oid);\n\n",
     888             :                               auth_oid);
     889             :         }
     890             : 
     891             :         /*
     892             :          * We dump CREATE ROLE followed by ALTER ROLE to ensure that the role
     893             :          * will acquire the right properties even if it already exists (ie, it
     894             :          * won't hurt for the CREATE to fail).  This is particularly important
     895             :          * for the role we are connected as, since even with --clean we will
     896             :          * have failed to drop it.  binary_upgrade cannot generate any errors,
     897             :          * so we assume the current role is already created.
     898             :          */
     899          98 :         if (!binary_upgrade ||
     900           2 :             strcmp(PQgetvalue(res, i, i_is_current_user), "f") == 0)
     901          94 :             appendPQExpBuffer(buf, "CREATE ROLE %s;\n", fmtId(rolename));
     902          96 :         appendPQExpBuffer(buf, "ALTER ROLE %s WITH", fmtId(rolename));
     903             : 
     904          96 :         if (strcmp(PQgetvalue(res, i, i_rolsuper), "t") == 0)
     905          86 :             appendPQExpBufferStr(buf, " SUPERUSER");
     906             :         else
     907          10 :             appendPQExpBufferStr(buf, " NOSUPERUSER");
     908             : 
     909          96 :         if (strcmp(PQgetvalue(res, i, i_rolinherit), "t") == 0)
     910          96 :             appendPQExpBufferStr(buf, " INHERIT");
     911             :         else
     912           0 :             appendPQExpBufferStr(buf, " NOINHERIT");
     913             : 
     914          96 :         if (strcmp(PQgetvalue(res, i, i_rolcreaterole), "t") == 0)
     915          86 :             appendPQExpBufferStr(buf, " CREATEROLE");
     916             :         else
     917          10 :             appendPQExpBufferStr(buf, " NOCREATEROLE");
     918             : 
     919          96 :         if (strcmp(PQgetvalue(res, i, i_rolcreatedb), "t") == 0)
     920          86 :             appendPQExpBufferStr(buf, " CREATEDB");
     921             :         else
     922          10 :             appendPQExpBufferStr(buf, " NOCREATEDB");
     923             : 
     924          96 :         if (strcmp(PQgetvalue(res, i, i_rolcanlogin), "t") == 0)
     925          86 :             appendPQExpBufferStr(buf, " LOGIN");
     926             :         else
     927          10 :             appendPQExpBufferStr(buf, " NOLOGIN");
     928             : 
     929          96 :         if (strcmp(PQgetvalue(res, i, i_rolreplication), "t") == 0)
     930          30 :             appendPQExpBufferStr(buf, " REPLICATION");
     931             :         else
     932          66 :             appendPQExpBufferStr(buf, " NOREPLICATION");
     933             : 
     934          96 :         if (strcmp(PQgetvalue(res, i, i_rolbypassrls), "t") == 0)
     935          30 :             appendPQExpBufferStr(buf, " BYPASSRLS");
     936             :         else
     937          66 :             appendPQExpBufferStr(buf, " NOBYPASSRLS");
     938             : 
     939          96 :         if (strcmp(PQgetvalue(res, i, i_rolconnlimit), "-1") != 0)
     940           0 :             appendPQExpBuffer(buf, " CONNECTION LIMIT %s",
     941             :                               PQgetvalue(res, i, i_rolconnlimit));
     942             : 
     943             : 
     944          96 :         if (!PQgetisnull(res, i, i_rolpassword) && !no_role_passwords)
     945             :         {
     946           0 :             appendPQExpBufferStr(buf, " PASSWORD ");
     947           0 :             appendStringLiteralConn(buf, PQgetvalue(res, i, i_rolpassword), conn);
     948             :         }
     949             : 
     950          96 :         if (!PQgetisnull(res, i, i_rolvaliduntil))
     951           0 :             appendPQExpBuffer(buf, " VALID UNTIL '%s'",
     952             :                               PQgetvalue(res, i, i_rolvaliduntil));
     953             : 
     954          96 :         appendPQExpBufferStr(buf, ";\n");
     955             : 
     956          96 :         if (!no_comments && !PQgetisnull(res, i, i_rolcomment))
     957             :         {
     958           0 :             appendPQExpBuffer(buf, "COMMENT ON ROLE %s IS ", fmtId(rolename));
     959           0 :             appendStringLiteralConn(buf, PQgetvalue(res, i, i_rolcomment), conn);
     960           0 :             appendPQExpBufferStr(buf, ";\n");
     961             :         }
     962             : 
     963          96 :         if (!no_security_labels && server_version >= 90200)
     964          96 :             buildShSecLabels(conn, "pg_authid", auth_oid,
     965             :                              "ROLE", rolename,
     966             :                              buf);
     967             : 
     968          96 :         fprintf(OPF, "%s", buf->data);
     969             :     }
     970             : 
     971             :     /*
     972             :      * Dump configuration settings for roles after all roles have been dumped.
     973             :      * We do it this way because config settings for roles could mention the
     974             :      * names of other roles.
     975             :      */
     976         126 :     for (i = 0; i < PQntuples(res); i++)
     977          96 :         dumpUserConfig(conn, PQgetvalue(res, i, i_rolname));
     978             : 
     979          30 :     PQclear(res);
     980             : 
     981          30 :     fprintf(OPF, "\n\n");
     982             : 
     983          30 :     destroyPQExpBuffer(buf);
     984          30 : }
     985             : 
     986             : 
     987             : /*
     988             :  * Dump role memberships.  This code is used for 8.1 and later servers.
     989             :  *
     990             :  * Note: we expect dumpRoles already created all the roles, but there is
     991             :  * no membership yet.
     992             :  */
     993             : static void
     994          30 : dumpRoleMembership(PGconn *conn)
     995             : {
     996          30 :     PQExpBuffer buf = createPQExpBuffer();
     997             :     PGresult   *res;
     998             :     int         i;
     999             : 
    1000          30 :     printfPQExpBuffer(buf, "SELECT ur.rolname AS roleid, "
    1001             :                       "um.rolname AS member, "
    1002             :                       "a.admin_option, "
    1003             :                       "ug.rolname AS grantor "
    1004             :                       "FROM pg_auth_members a "
    1005             :                       "LEFT JOIN %s ur on ur.oid = a.roleid "
    1006             :                       "LEFT JOIN %s um on um.oid = a.member "
    1007             :                       "LEFT JOIN %s ug on ug.oid = a.grantor "
    1008             :                       "WHERE NOT (ur.rolname ~ '^pg_' AND um.rolname ~ '^pg_')"
    1009             :                       "ORDER BY 1,2,3", role_catalog, role_catalog, role_catalog);
    1010          30 :     res = executeQuery(conn, buf->data);
    1011             : 
    1012          30 :     if (PQntuples(res) > 0)
    1013           0 :         fprintf(OPF, "--\n-- Role memberships\n--\n\n");
    1014             : 
    1015          30 :     for (i = 0; i < PQntuples(res); i++)
    1016             :     {
    1017           0 :         char       *roleid = PQgetvalue(res, i, 0);
    1018           0 :         char       *member = PQgetvalue(res, i, 1);
    1019           0 :         char       *option = PQgetvalue(res, i, 2);
    1020             : 
    1021           0 :         fprintf(OPF, "GRANT %s", fmtId(roleid));
    1022           0 :         fprintf(OPF, " TO %s", fmtId(member));
    1023           0 :         if (*option == 't')
    1024           0 :             fprintf(OPF, " WITH ADMIN OPTION");
    1025             : 
    1026             :         /*
    1027             :          * We don't track the grantor very carefully in the backend, so cope
    1028             :          * with the possibility that it has been dropped.
    1029             :          */
    1030           0 :         if (!PQgetisnull(res, i, 3))
    1031             :         {
    1032           0 :             char       *grantor = PQgetvalue(res, i, 3);
    1033             : 
    1034           0 :             fprintf(OPF, " GRANTED BY %s", fmtId(grantor));
    1035             :         }
    1036           0 :         fprintf(OPF, ";\n");
    1037             :     }
    1038             : 
    1039          30 :     PQclear(res);
    1040          30 :     destroyPQExpBuffer(buf);
    1041             : 
    1042          30 :     fprintf(OPF, "\n\n");
    1043          30 : }
    1044             : 
    1045             : /*
    1046             :  * Dump group memberships from a pre-8.1 server.  It's annoying that we
    1047             :  * can't share any useful amount of code with the post-8.1 case, but
    1048             :  * the catalog representations are too different.
    1049             :  *
    1050             :  * Note: we expect dumpRoles already created all the roles, but there is
    1051             :  * no membership yet.
    1052             :  */
    1053             : static void
    1054           0 : dumpGroups(PGconn *conn)
    1055             : {
    1056           0 :     PQExpBuffer buf = createPQExpBuffer();
    1057             :     PGresult   *res;
    1058             :     int         i;
    1059             : 
    1060           0 :     res = executeQuery(conn,
    1061             :                        "SELECT groname, grolist FROM pg_group ORDER BY 1");
    1062             : 
    1063           0 :     if (PQntuples(res) > 0)
    1064           0 :         fprintf(OPF, "--\n-- Role memberships\n--\n\n");
    1065             : 
    1066           0 :     for (i = 0; i < PQntuples(res); i++)
    1067             :     {
    1068           0 :         char       *groname = PQgetvalue(res, i, 0);
    1069           0 :         char       *grolist = PQgetvalue(res, i, 1);
    1070             :         PGresult   *res2;
    1071             :         int         j;
    1072             : 
    1073             :         /*
    1074             :          * Array representation is {1,2,3} ... convert to (1,2,3)
    1075             :          */
    1076           0 :         if (strlen(grolist) < 3)
    1077           0 :             continue;
    1078             : 
    1079           0 :         grolist = pg_strdup(grolist);
    1080           0 :         grolist[0] = '(';
    1081           0 :         grolist[strlen(grolist) - 1] = ')';
    1082           0 :         printfPQExpBuffer(buf,
    1083             :                           "SELECT usename FROM pg_shadow "
    1084             :                           "WHERE usesysid IN %s ORDER BY 1",
    1085             :                           grolist);
    1086           0 :         free(grolist);
    1087             : 
    1088           0 :         res2 = executeQuery(conn, buf->data);
    1089             : 
    1090           0 :         for (j = 0; j < PQntuples(res2); j++)
    1091             :         {
    1092           0 :             char       *usename = PQgetvalue(res2, j, 0);
    1093             : 
    1094             :             /*
    1095             :              * Don't try to grant a role to itself; can happen if old
    1096             :              * installation has identically named user and group.
    1097             :              */
    1098           0 :             if (strcmp(groname, usename) == 0)
    1099           0 :                 continue;
    1100             : 
    1101           0 :             fprintf(OPF, "GRANT %s", fmtId(groname));
    1102           0 :             fprintf(OPF, " TO %s;\n", fmtId(usename));
    1103             :         }
    1104             : 
    1105           0 :         PQclear(res2);
    1106             :     }
    1107             : 
    1108           0 :     PQclear(res);
    1109           0 :     destroyPQExpBuffer(buf);
    1110             : 
    1111           0 :     fprintf(OPF, "\n\n");
    1112           0 : }
    1113             : 
    1114             : 
    1115             : /*
    1116             :  * Drop tablespaces.
    1117             :  */
    1118             : static void
    1119           2 : dropTablespaces(PGconn *conn)
    1120             : {
    1121             :     PGresult   *res;
    1122             :     int         i;
    1123             : 
    1124             :     /*
    1125             :      * Get all tablespaces except built-in ones (which we assume are named
    1126             :      * pg_xxx)
    1127             :      */
    1128           2 :     res = executeQuery(conn, "SELECT spcname "
    1129             :                        "FROM pg_catalog.pg_tablespace "
    1130             :                        "WHERE spcname !~ '^pg_' "
    1131             :                        "ORDER BY 1");
    1132             : 
    1133           2 :     if (PQntuples(res) > 0)
    1134           0 :         fprintf(OPF, "--\n-- Drop tablespaces\n--\n\n");
    1135             : 
    1136           2 :     for (i = 0; i < PQntuples(res); i++)
    1137             :     {
    1138           0 :         char       *spcname = PQgetvalue(res, i, 0);
    1139             : 
    1140           0 :         fprintf(OPF, "DROP TABLESPACE %s%s;\n",
    1141           0 :                 if_exists ? "IF EXISTS " : "",
    1142             :                 fmtId(spcname));
    1143             :     }
    1144             : 
    1145           2 :     PQclear(res);
    1146             : 
    1147           2 :     fprintf(OPF, "\n\n");
    1148           2 : }
    1149             : 
    1150             : /*
    1151             :  * Dump tablespaces.
    1152             :  */
    1153             : static void
    1154          20 : dumpTablespaces(PGconn *conn)
    1155             : {
    1156             :     PGresult   *res;
    1157             :     int         i;
    1158             : 
    1159             :     /*
    1160             :      * Get all tablespaces except built-in ones (which we assume are named
    1161             :      * pg_xxx)
    1162             :      *
    1163             :      * For the tablespace ACLs, as of 9.6, we extract both the positive (as
    1164             :      * spcacl) and negative (as rspcacl) ACLs, relative to the default ACL for
    1165             :      * tablespaces, which are then passed to buildACLCommands() below.
    1166             :      *
    1167             :      * See buildACLQueries() and buildACLCommands().
    1168             :      *
    1169             :      * The order in which privileges are in the ACL string (the order they
    1170             :      * have been GRANT'd in, which the backend maintains) must be preserved to
    1171             :      * ensure that GRANTs WITH GRANT OPTION and subsequent GRANTs based on
    1172             :      * those are dumped in the correct order.
    1173             :      *
    1174             :      * Note that we do not support initial privileges (pg_init_privs) on
    1175             :      * tablespaces, so this logic cannot make use of buildACLQueries().
    1176             :      */
    1177          20 :     if (server_version >= 90600)
    1178          20 :         res = executeQuery(conn, "SELECT oid, spcname, "
    1179             :                            "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
    1180             :                            "pg_catalog.pg_tablespace_location(oid), "
    1181             :                            "(SELECT array_agg(acl ORDER BY row_n) FROM "
    1182             :                            "  (SELECT acl, row_n FROM "
    1183             :                            "     unnest(coalesce(spcacl,acldefault('t',spcowner))) "
    1184             :                            "     WITH ORDINALITY AS perm(acl,row_n) "
    1185             :                            "   WHERE NOT EXISTS ( "
    1186             :                            "     SELECT 1 "
    1187             :                            "     FROM unnest(acldefault('t',spcowner)) "
    1188             :                            "       AS init(init_acl) "
    1189             :                            "     WHERE acl = init_acl)) AS spcacls) "
    1190             :                            " AS spcacl, "
    1191             :                            "(SELECT array_agg(acl ORDER BY row_n) FROM "
    1192             :                            "  (SELECT acl, row_n FROM "
    1193             :                            "     unnest(acldefault('t',spcowner)) "
    1194             :                            "     WITH ORDINALITY AS initp(acl,row_n) "
    1195             :                            "   WHERE NOT EXISTS ( "
    1196             :                            "     SELECT 1 "
    1197             :                            "     FROM unnest(coalesce(spcacl,acldefault('t',spcowner))) "
    1198             :                            "       AS permp(orig_acl) "
    1199             :                            "     WHERE acl = orig_acl)) AS rspcacls) "
    1200             :                            " AS rspcacl, "
    1201             :                            "array_to_string(spcoptions, ', '),"
    1202             :                            "pg_catalog.shobj_description(oid, 'pg_tablespace') "
    1203             :                            "FROM pg_catalog.pg_tablespace "
    1204             :                            "WHERE spcname !~ '^pg_' "
    1205             :                            "ORDER BY 1");
    1206           0 :     else if (server_version >= 90200)
    1207           0 :         res = executeQuery(conn, "SELECT oid, spcname, "
    1208             :                            "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
    1209             :                            "pg_catalog.pg_tablespace_location(oid), "
    1210             :                            "spcacl, '' as rspcacl, "
    1211             :                            "array_to_string(spcoptions, ', '),"
    1212             :                            "pg_catalog.shobj_description(oid, 'pg_tablespace') "
    1213             :                            "FROM pg_catalog.pg_tablespace "
    1214             :                            "WHERE spcname !~ '^pg_' "
    1215             :                            "ORDER BY 1");
    1216           0 :     else if (server_version >= 90000)
    1217           0 :         res = executeQuery(conn, "SELECT oid, spcname, "
    1218             :                            "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
    1219             :                            "spclocation, spcacl, '' as rspcacl, "
    1220             :                            "array_to_string(spcoptions, ', '),"
    1221             :                            "pg_catalog.shobj_description(oid, 'pg_tablespace') "
    1222             :                            "FROM pg_catalog.pg_tablespace "
    1223             :                            "WHERE spcname !~ '^pg_' "
    1224             :                            "ORDER BY 1");
    1225           0 :     else if (server_version >= 80200)
    1226           0 :         res = executeQuery(conn, "SELECT oid, spcname, "
    1227             :                            "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
    1228             :                            "spclocation, spcacl, '' as rspcacl, null, "
    1229             :                            "pg_catalog.shobj_description(oid, 'pg_tablespace') "
    1230             :                            "FROM pg_catalog.pg_tablespace "
    1231             :                            "WHERE spcname !~ '^pg_' "
    1232             :                            "ORDER BY 1");
    1233             :     else
    1234           0 :         res = executeQuery(conn, "SELECT oid, spcname, "
    1235             :                            "pg_catalog.pg_get_userbyid(spcowner) AS spcowner, "
    1236             :                            "spclocation, spcacl, '' as rspcacl, "
    1237             :                            "null, null "
    1238             :                            "FROM pg_catalog.pg_tablespace "
    1239             :                            "WHERE spcname !~ '^pg_' "
    1240             :                            "ORDER BY 1");
    1241             : 
    1242          20 :     if (PQntuples(res) > 0)
    1243           0 :         fprintf(OPF, "--\n-- Tablespaces\n--\n\n");
    1244             : 
    1245          20 :     for (i = 0; i < PQntuples(res); i++)
    1246             :     {
    1247           0 :         PQExpBuffer buf = createPQExpBuffer();
    1248           0 :         Oid         spcoid = atooid(PQgetvalue(res, i, 0));
    1249           0 :         char       *spcname = PQgetvalue(res, i, 1);
    1250           0 :         char       *spcowner = PQgetvalue(res, i, 2);
    1251           0 :         char       *spclocation = PQgetvalue(res, i, 3);
    1252           0 :         char       *spcacl = PQgetvalue(res, i, 4);
    1253           0 :         char       *rspcacl = PQgetvalue(res, i, 5);
    1254           0 :         char       *spcoptions = PQgetvalue(res, i, 6);
    1255           0 :         char       *spccomment = PQgetvalue(res, i, 7);
    1256             :         char       *fspcname;
    1257             : 
    1258             :         /* needed for buildACLCommands() */
    1259           0 :         fspcname = pg_strdup(fmtId(spcname));
    1260             : 
    1261           0 :         appendPQExpBuffer(buf, "CREATE TABLESPACE %s", fspcname);
    1262           0 :         appendPQExpBuffer(buf, " OWNER %s", fmtId(spcowner));
    1263             : 
    1264           0 :         appendPQExpBufferStr(buf, " LOCATION ");
    1265           0 :         appendStringLiteralConn(buf, spclocation, conn);
    1266           0 :         appendPQExpBufferStr(buf, ";\n");
    1267             : 
    1268           0 :         if (spcoptions && spcoptions[0] != '\0')
    1269           0 :             appendPQExpBuffer(buf, "ALTER TABLESPACE %s SET (%s);\n",
    1270             :                               fspcname, spcoptions);
    1271             : 
    1272           0 :         if (!skip_acls &&
    1273           0 :             !buildACLCommands(fspcname, NULL, NULL, "TABLESPACE",
    1274             :                               spcacl, rspcacl,
    1275             :                               spcowner, "", server_version, buf))
    1276             :         {
    1277           0 :             pg_log_error("could not parse ACL list (%s) for tablespace \"%s\"",
    1278             :                          spcacl, spcname);
    1279           0 :             PQfinish(conn);
    1280           0 :             exit_nicely(1);
    1281             :         }
    1282             : 
    1283           0 :         if (!no_comments && spccomment && spccomment[0] != '\0')
    1284             :         {
    1285           0 :             appendPQExpBuffer(buf, "COMMENT ON TABLESPACE %s IS ", fspcname);
    1286           0 :             appendStringLiteralConn(buf, spccomment, conn);
    1287           0 :             appendPQExpBufferStr(buf, ";\n");
    1288             :         }
    1289             : 
    1290           0 :         if (!no_security_labels && server_version >= 90200)
    1291           0 :             buildShSecLabels(conn, "pg_tablespace", spcoid,
    1292             :                              "TABLESPACE", spcname,
    1293             :                              buf);
    1294             : 
    1295           0 :         fprintf(OPF, "%s", buf->data);
    1296             : 
    1297           0 :         free(fspcname);
    1298           0 :         destroyPQExpBuffer(buf);
    1299             :     }
    1300             : 
    1301          20 :     PQclear(res);
    1302          20 :     fprintf(OPF, "\n\n");
    1303          20 : }
    1304             : 
    1305             : 
    1306             : /*
    1307             :  * Dump commands to drop each database.
    1308             :  */
    1309             : static void
    1310           0 : dropDBs(PGconn *conn)
    1311             : {
    1312             :     PGresult   *res;
    1313             :     int         i;
    1314             : 
    1315             :     /*
    1316             :      * Skip databases marked not datallowconn, since we'd be unable to connect
    1317             :      * to them anyway.  This must agree with dumpDatabases().
    1318             :      */
    1319           0 :     res = executeQuery(conn,
    1320             :                        "SELECT datname "
    1321             :                        "FROM pg_database d "
    1322             :                        "WHERE datallowconn "
    1323             :                        "ORDER BY datname");
    1324             : 
    1325           0 :     if (PQntuples(res) > 0)
    1326           0 :         fprintf(OPF, "--\n-- Drop databases (except postgres and template1)\n--\n\n");
    1327             : 
    1328           0 :     for (i = 0; i < PQntuples(res); i++)
    1329             :     {
    1330           0 :         char       *dbname = PQgetvalue(res, i, 0);
    1331             : 
    1332             :         /*
    1333             :          * Skip "postgres" and "template1"; dumpDatabases() will deal with
    1334             :          * them specially.  Also, be sure to skip "template0", even if for
    1335             :          * some reason it's not marked !datallowconn.
    1336             :          */
    1337           0 :         if (strcmp(dbname, "template1") != 0 &&
    1338           0 :             strcmp(dbname, "template0") != 0 &&
    1339           0 :             strcmp(dbname, "postgres") != 0)
    1340             :         {
    1341           0 :             fprintf(OPF, "DROP DATABASE %s%s;\n",
    1342           0 :                     if_exists ? "IF EXISTS " : "",
    1343             :                     fmtId(dbname));
    1344             :         }
    1345             :     }
    1346             : 
    1347           0 :     PQclear(res);
    1348             : 
    1349           0 :     fprintf(OPF, "\n\n");
    1350           0 : }
    1351             : 
    1352             : 
    1353             : /*
    1354             :  * Dump user-specific configuration
    1355             :  */
    1356             : static void
    1357          96 : dumpUserConfig(PGconn *conn, const char *username)
    1358             : {
    1359          96 :     PQExpBuffer buf = createPQExpBuffer();
    1360          96 :     int         count = 1;
    1361          96 :     bool        first = true;
    1362             : 
    1363             :     for (;;)
    1364           0 :     {
    1365             :         PGresult   *res;
    1366             : 
    1367          96 :         if (server_version >= 90000)
    1368          96 :             printfPQExpBuffer(buf, "SELECT setconfig[%d] FROM pg_db_role_setting WHERE "
    1369             :                               "setdatabase = 0 AND setrole = "
    1370             :                               "(SELECT oid FROM %s WHERE rolname = ", count, role_catalog);
    1371           0 :         else if (server_version >= 80100)
    1372           0 :             printfPQExpBuffer(buf, "SELECT rolconfig[%d] FROM %s WHERE rolname = ", count, role_catalog);
    1373             :         else
    1374           0 :             printfPQExpBuffer(buf, "SELECT useconfig[%d] FROM pg_shadow WHERE usename = ", count);
    1375          96 :         appendStringLiteralConn(buf, username, conn);
    1376          96 :         if (server_version >= 90000)
    1377          96 :             appendPQExpBufferChar(buf, ')');
    1378             : 
    1379          96 :         res = executeQuery(conn, buf->data);
    1380          96 :         if (PQntuples(res) == 1 &&
    1381           0 :             !PQgetisnull(res, 0, 0))
    1382             :         {
    1383             :             /* comment at section start, only if needed */
    1384           0 :             if (first)
    1385             :             {
    1386           0 :                 fprintf(OPF, "--\n-- User Configurations\n--\n\n");
    1387           0 :                 first = false;
    1388             :             }
    1389             : 
    1390           0 :             fprintf(OPF, "--\n-- User Config \"%s\"\n--\n\n", username);
    1391           0 :             resetPQExpBuffer(buf);
    1392           0 :             makeAlterConfigCommand(conn, PQgetvalue(res, 0, 0),
    1393             :                                    "ROLE", username, NULL, NULL,
    1394             :                                    buf);
    1395           0 :             fprintf(OPF, "%s", buf->data);
    1396           0 :             PQclear(res);
    1397           0 :             count++;
    1398             :         }
    1399             :         else
    1400             :         {
    1401          96 :             PQclear(res);
    1402          96 :             break;
    1403             :         }
    1404             :     }
    1405             : 
    1406          96 :     destroyPQExpBuffer(buf);
    1407          96 : }
    1408             : 
    1409             : /*
    1410             :  * Find a list of database names that match the given patterns.
    1411             :  * See also expand_table_name_patterns() in pg_dump.c
    1412             :  */
    1413             : static void
    1414          30 : expand_dbname_patterns(PGconn *conn,
    1415             :                        SimpleStringList *patterns,
    1416             :                        SimpleStringList *names)
    1417             : {
    1418             :     PQExpBuffer query;
    1419             :     PGresult   *res;
    1420             : 
    1421          30 :     if (patterns->head == NULL)
    1422          28 :         return;                 /* nothing to do */
    1423             : 
    1424           2 :     query = createPQExpBuffer();
    1425             : 
    1426             :     /*
    1427             :      * The loop below runs multiple SELECTs, which might sometimes result in
    1428             :      * duplicate entries in the name list, but we don't care, since all we're
    1429             :      * going to do is test membership of the list.
    1430             :      */
    1431             : 
    1432           4 :     for (SimpleStringListCell *cell = patterns->head; cell; cell = cell->next)
    1433             :     {
    1434           2 :         appendPQExpBufferStr(query,
    1435             :                              "SELECT datname FROM pg_catalog.pg_database n\n");
    1436           2 :         processSQLNamePattern(conn, query, cell->val, false,
    1437             :                               false, NULL, "datname", NULL, NULL);
    1438             : 
    1439           2 :         res = executeQuery(conn, query->data);
    1440           8 :         for (int i = 0; i < PQntuples(res); i++)
    1441             :         {
    1442           6 :             simple_string_list_append(names, PQgetvalue(res, i, 0));
    1443             :         }
    1444             : 
    1445           2 :         PQclear(res);
    1446           2 :         resetPQExpBuffer(query);
    1447             :     }
    1448             : 
    1449           2 :     destroyPQExpBuffer(query);
    1450             : }
    1451             : 
    1452             : /*
    1453             :  * Dump contents of databases.
    1454             :  */
    1455             : static void
    1456          12 : dumpDatabases(PGconn *conn)
    1457             : {
    1458             :     PGresult   *res;
    1459             :     int         i;
    1460             : 
    1461             :     /*
    1462             :      * Skip databases marked not datallowconn, since we'd be unable to connect
    1463             :      * to them anyway.  This must agree with dropDBs().
    1464             :      *
    1465             :      * We arrange for template1 to be processed first, then we process other
    1466             :      * DBs in alphabetical order.  If we just did them all alphabetically, we
    1467             :      * might find ourselves trying to drop the "postgres" database while still
    1468             :      * connected to it.  This makes trying to run the restore script while
    1469             :      * connected to "template1" a bad idea, but there's no fixed order that
    1470             :      * doesn't have some failure mode with --clean.
    1471             :      */
    1472          12 :     res = executeQuery(conn,
    1473             :                        "SELECT datname "
    1474             :                        "FROM pg_database d "
    1475             :                        "WHERE datallowconn "
    1476             :                        "ORDER BY (datname <> 'template1'), datname");
    1477             : 
    1478          12 :     if (PQntuples(res) > 0)
    1479          12 :         fprintf(OPF, "--\n-- Databases\n--\n\n");
    1480             : 
    1481          70 :     for (i = 0; i < PQntuples(res); i++)
    1482             :     {
    1483          60 :         char       *dbname = PQgetvalue(res, i, 0);
    1484             :         const char *create_opts;
    1485             :         int         ret;
    1486             : 
    1487             :         /* Skip template0, even if it's not marked !datallowconn. */
    1488          60 :         if (strcmp(dbname, "template0") == 0)
    1489           0 :             continue;
    1490             : 
    1491             :         /* Skip any explicitly excluded database */
    1492          60 :         if (simple_string_list_member(&database_exclude_names, dbname))
    1493             :         {
    1494           6 :             pg_log_info("excluding database \"%s\"", dbname);
    1495           6 :             continue;
    1496             :         }
    1497             : 
    1498          54 :         pg_log_info("dumping database \"%s\"", dbname);
    1499             : 
    1500          54 :         fprintf(OPF, "--\n-- Database \"%s\" dump\n--\n\n", dbname);
    1501             : 
    1502             :         /*
    1503             :          * We assume that "template1" and "postgres" already exist in the
    1504             :          * target installation.  dropDBs() won't have removed them, for fear
    1505             :          * of removing the DB the restore script is initially connected to. If
    1506             :          * --clean was specified, tell pg_dump to drop and recreate them;
    1507             :          * otherwise we'll merely restore their contents.  Other databases
    1508             :          * should simply be created.
    1509             :          */
    1510          54 :         if (strcmp(dbname, "template1") == 0 || strcmp(dbname, "postgres") == 0)
    1511             :         {
    1512          44 :             if (output_clean)
    1513           0 :                 create_opts = "--clean --create";
    1514             :             else
    1515             :             {
    1516          22 :                 create_opts = "";
    1517             :                 /* Since pg_dump won't emit a \connect command, we must */
    1518          22 :                 fprintf(OPF, "\\connect %s\n\n", dbname);
    1519             :             }
    1520             :         }
    1521             :         else
    1522          32 :             create_opts = "--create";
    1523             : 
    1524          54 :         if (filename)
    1525          54 :             fclose(OPF);
    1526             : 
    1527          54 :         ret = runPgDump(dbname, create_opts);
    1528          52 :         if (ret != 0)
    1529             :         {
    1530           0 :             pg_log_error("pg_dump failed on database \"%s\", exiting", dbname);
    1531           0 :             exit_nicely(1);
    1532             :         }
    1533             : 
    1534          52 :         if (filename)
    1535             :         {
    1536          52 :             OPF = fopen(filename, PG_BINARY_A);
    1537          52 :             if (!OPF)
    1538             :             {
    1539           0 :                 pg_log_error("could not re-open the output file \"%s\": %m",
    1540             :                              filename);
    1541           0 :                 exit_nicely(1);
    1542             :             }
    1543             :         }
    1544             : 
    1545             :     }
    1546             : 
    1547          10 :     PQclear(res);
    1548          10 : }
    1549             : 
    1550             : 
    1551             : 
    1552             : /*
    1553             :  * Run pg_dump on dbname, with specified options.
    1554             :  */
    1555             : static int
    1556          54 : runPgDump(const char *dbname, const char *create_opts)
    1557             : {
    1558          54 :     PQExpBuffer connstrbuf = createPQExpBuffer();
    1559          54 :     PQExpBuffer cmd = createPQExpBuffer();
    1560             :     int         ret;
    1561             : 
    1562          54 :     appendPQExpBuffer(cmd, "\"%s\" %s %s", pg_dump_bin,
    1563          54 :                       pgdumpopts->data, create_opts);
    1564             : 
    1565             :     /*
    1566             :      * If we have a filename, use the undocumented plain-append pg_dump
    1567             :      * format.
    1568             :      */
    1569          54 :     if (filename)
    1570          54 :         appendPQExpBufferStr(cmd, " -Fa ");
    1571             :     else
    1572           0 :         appendPQExpBufferStr(cmd, " -Fp ");
    1573             : 
    1574             :     /*
    1575             :      * Append the database name to the already-constructed stem of connection
    1576             :      * string.
    1577             :      */
    1578          54 :     appendPQExpBuffer(connstrbuf, "%s dbname=", connstr);
    1579          54 :     appendConnStrVal(connstrbuf, dbname);
    1580             : 
    1581          54 :     appendShellString(cmd, connstrbuf->data);
    1582             : 
    1583          52 :     pg_log_info("running \"%s\"", cmd->data);
    1584             : 
    1585          52 :     fflush(stdout);
    1586          52 :     fflush(stderr);
    1587             : 
    1588          52 :     ret = system(cmd->data);
    1589             : 
    1590          52 :     destroyPQExpBuffer(cmd);
    1591          52 :     destroyPQExpBuffer(connstrbuf);
    1592             : 
    1593          52 :     return ret;
    1594             : }
    1595             : 
    1596             : /*
    1597             :  * buildShSecLabels
    1598             :  *
    1599             :  * Build SECURITY LABEL command(s) for a shared object
    1600             :  *
    1601             :  * The caller has to provide object type and identity in two separate formats:
    1602             :  * catalog_name (e.g., "pg_database") and object OID, as well as
    1603             :  * type name (e.g., "DATABASE") and object name (not pre-quoted).
    1604             :  *
    1605             :  * The command(s) are appended to "buffer".
    1606             :  */
    1607             : static void
    1608          96 : buildShSecLabels(PGconn *conn, const char *catalog_name, Oid objectId,
    1609             :                  const char *objtype, const char *objname,
    1610             :                  PQExpBuffer buffer)
    1611             : {
    1612          96 :     PQExpBuffer sql = createPQExpBuffer();
    1613             :     PGresult   *res;
    1614             : 
    1615          96 :     buildShSecLabelQuery(conn, catalog_name, objectId, sql);
    1616          96 :     res = executeQuery(conn, sql->data);
    1617          96 :     emitShSecLabels(conn, res, buffer, objtype, objname);
    1618             : 
    1619          96 :     PQclear(res);
    1620          96 :     destroyPQExpBuffer(sql);
    1621          96 : }
    1622             : 
    1623             : /*
    1624             :  * Make a database connection with the given parameters.  An
    1625             :  * interactive password prompt is automatically issued if required.
    1626             :  *
    1627             :  * If fail_on_error is false, we return NULL without printing any message
    1628             :  * on failure, but preserve any prompted password for the next try.
    1629             :  *
    1630             :  * On success, the global variable 'connstr' is set to a connection string
    1631             :  * containing the options used.
    1632             :  */
    1633             : static PGconn *
    1634          30 : connectDatabase(const char *dbname, const char *connection_string,
    1635             :                 const char *pghost, const char *pgport, const char *pguser,
    1636             :                 trivalue prompt_password, bool fail_on_error)
    1637             : {
    1638             :     PGconn     *conn;
    1639             :     bool        new_pass;
    1640             :     const char *remoteversion_str;
    1641             :     int         my_version;
    1642          30 :     const char **keywords = NULL;
    1643          30 :     const char **values = NULL;
    1644          30 :     PQconninfoOption *conn_opts = NULL;
    1645             :     static bool have_password = false;
    1646             :     static char password[100];
    1647             : 
    1648          30 :     if (prompt_password == TRI_YES && !have_password)
    1649             :     {
    1650           0 :         simple_prompt("Password: ", password, sizeof(password), false);
    1651           0 :         have_password = true;
    1652             :     }
    1653             : 
    1654             :     /*
    1655             :      * Start the connection.  Loop until we have a password if requested by
    1656             :      * backend.
    1657             :      */
    1658             :     do
    1659             :     {
    1660          30 :         int         argcount = 6;
    1661             :         PQconninfoOption *conn_opt;
    1662          30 :         char       *err_msg = NULL;
    1663          30 :         int         i = 0;
    1664             : 
    1665          30 :         if (keywords)
    1666           0 :             free(keywords);
    1667          30 :         if (values)
    1668           0 :             free(values);
    1669          30 :         if (conn_opts)
    1670           0 :             PQconninfoFree(conn_opts);
    1671             : 
    1672             :         /*
    1673             :          * Merge the connection info inputs given in form of connection string
    1674             :          * and other options.  Explicitly discard any dbname value in the
    1675             :          * connection string; otherwise, PQconnectdbParams() would interpret
    1676             :          * that value as being itself a connection string.
    1677             :          */
    1678          30 :         if (connection_string)
    1679             :         {
    1680          30 :             conn_opts = PQconninfoParse(connection_string, &err_msg);
    1681          30 :             if (conn_opts == NULL)
    1682             :             {
    1683           0 :                 pg_log_error("%s", err_msg);
    1684           0 :                 exit_nicely(1);
    1685             :             }
    1686             : 
    1687         960 :             for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
    1688             :             {
    1689         954 :                 if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
    1690          24 :                     strcmp(conn_opt->keyword, "dbname") != 0)
    1691          16 :                     argcount++;
    1692             :             }
    1693             : 
    1694          30 :             keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
    1695          30 :             values = pg_malloc0((argcount + 1) * sizeof(*values));
    1696             : 
    1697         960 :             for (conn_opt = conn_opts; conn_opt->keyword != NULL; conn_opt++)
    1698             :             {
    1699         954 :                 if (conn_opt->val != NULL && conn_opt->val[0] != '\0' &&
    1700          24 :                     strcmp(conn_opt->keyword, "dbname") != 0)
    1701             :                 {
    1702          16 :                     keywords[i] = conn_opt->keyword;
    1703          16 :                     values[i] = conn_opt->val;
    1704          16 :                     i++;
    1705             :                 }
    1706             :             }
    1707             :         }
    1708             :         else
    1709             :         {
    1710           0 :             keywords = pg_malloc0((argcount + 1) * sizeof(*keywords));
    1711           0 :             values = pg_malloc0((argcount + 1) * sizeof(*values));
    1712             :         }
    1713             : 
    1714          30 :         if (pghost)
    1715             :         {
    1716           2 :             keywords[i] = "host";
    1717           2 :             values[i] = pghost;
    1718           2 :             i++;
    1719             :         }
    1720          30 :         if (pgport)
    1721             :         {
    1722           2 :             keywords[i] = "port";
    1723           2 :             values[i] = pgport;
    1724           2 :             i++;
    1725             :         }
    1726          30 :         if (pguser)
    1727             :         {
    1728          16 :             keywords[i] = "user";
    1729          16 :             values[i] = pguser;
    1730          16 :             i++;
    1731             :         }
    1732          30 :         if (have_password)
    1733             :         {
    1734           0 :             keywords[i] = "password";
    1735           0 :             values[i] = password;
    1736           0 :             i++;
    1737             :         }
    1738          30 :         if (dbname)
    1739             :         {
    1740          30 :             keywords[i] = "dbname";
    1741          30 :             values[i] = dbname;
    1742          30 :             i++;
    1743             :         }
    1744          30 :         keywords[i] = "fallback_application_name";
    1745          30 :         values[i] = progname;
    1746          30 :         i++;
    1747             : 
    1748          30 :         new_pass = false;
    1749          30 :         conn = PQconnectdbParams(keywords, values, true);
    1750             : 
    1751          30 :         if (!conn)
    1752             :         {
    1753           0 :             pg_log_error("could not connect to database \"%s\"", dbname);
    1754           0 :             exit_nicely(1);
    1755             :         }
    1756             : 
    1757          30 :         if (PQstatus(conn) == CONNECTION_BAD &&
    1758           0 :             PQconnectionNeedsPassword(conn) &&
    1759           0 :             !have_password &&
    1760             :             prompt_password != TRI_NO)
    1761             :         {
    1762           0 :             PQfinish(conn);
    1763           0 :             simple_prompt("Password: ", password, sizeof(password), false);
    1764           0 :             have_password = true;
    1765           0 :             new_pass = true;
    1766             :         }
    1767          30 :     } while (new_pass);
    1768             : 
    1769             :     /* check to see that the backend connection was successfully made */
    1770          30 :     if (PQstatus(conn) == CONNECTION_BAD)
    1771             :     {
    1772           0 :         if (fail_on_error)
    1773             :         {
    1774           0 :             pg_log_error("could not connect to database \"%s\": %s",
    1775             :                          dbname, PQerrorMessage(conn));
    1776           0 :             exit_nicely(1);
    1777             :         }
    1778             :         else
    1779             :         {
    1780           0 :             PQfinish(conn);
    1781             : 
    1782           0 :             free(keywords);
    1783           0 :             free(values);
    1784           0 :             PQconninfoFree(conn_opts);
    1785             : 
    1786           0 :             return NULL;
    1787             :         }
    1788             :     }
    1789             : 
    1790             :     /*
    1791             :      * Ok, connected successfully. Remember the options used, in the form of a
    1792             :      * connection string.
    1793             :      */
    1794          30 :     connstr = constructConnStr(keywords, values);
    1795             : 
    1796          30 :     free(keywords);
    1797          30 :     free(values);
    1798          30 :     PQconninfoFree(conn_opts);
    1799             : 
    1800             :     /* Check version */
    1801          30 :     remoteversion_str = PQparameterStatus(conn, "server_version");
    1802          30 :     if (!remoteversion_str)
    1803             :     {
    1804           0 :         pg_log_error("could not get server version");
    1805           0 :         exit_nicely(1);
    1806             :     }
    1807          30 :     server_version = PQserverVersion(conn);
    1808          30 :     if (server_version == 0)
    1809             :     {
    1810           0 :         pg_log_error("could not parse server version \"%s\"",
    1811             :                      remoteversion_str);
    1812           0 :         exit_nicely(1);
    1813             :     }
    1814             : 
    1815          30 :     my_version = PG_VERSION_NUM;
    1816             : 
    1817             :     /*
    1818             :      * We allow the server to be back to 8.0, and up to any minor release of
    1819             :      * our own major version.  (See also version check in pg_dump.c.)
    1820             :      */
    1821          30 :     if (my_version != server_version
    1822           0 :         && (server_version < 80000 ||
    1823           0 :             (server_version / 100) > (my_version / 100)))
    1824             :     {
    1825           0 :         pg_log_error("server version: %s; %s version: %s",
    1826             :                      remoteversion_str, progname, PG_VERSION);
    1827           0 :         pg_log_error("aborting because of server version mismatch");
    1828           0 :         exit_nicely(1);
    1829             :     }
    1830             : 
    1831          30 :     PQclear(executeQuery(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));
    1832             : 
    1833          30 :     return conn;
    1834             : }
    1835             : 
    1836             : /* ----------
    1837             :  * Construct a connection string from the given keyword/value pairs. It is
    1838             :  * used to pass the connection options to the pg_dump subprocess.
    1839             :  *
    1840             :  * The following parameters are excluded:
    1841             :  *  dbname      - varies in each pg_dump invocation
    1842             :  *  password    - it's not secure to pass a password on the command line
    1843             :  *  fallback_application_name - we'll let pg_dump set it
    1844             :  * ----------
    1845             :  */
    1846             : static char *
    1847          30 : constructConnStr(const char **keywords, const char **values)
    1848             : {
    1849          30 :     PQExpBuffer buf = createPQExpBuffer();
    1850             :     char       *connstr;
    1851             :     int         i;
    1852          30 :     bool        firstkeyword = true;
    1853             : 
    1854             :     /* Construct a new connection string in key='value' format. */
    1855         126 :     for (i = 0; keywords[i] != NULL; i++)
    1856             :     {
    1857         162 :         if (strcmp(keywords[i], "dbname") == 0 ||
    1858         132 :             strcmp(keywords[i], "password") == 0 ||
    1859          66 :             strcmp(keywords[i], "fallback_application_name") == 0)
    1860          60 :             continue;
    1861             : 
    1862          36 :         if (!firstkeyword)
    1863          20 :             appendPQExpBufferChar(buf, ' ');
    1864          36 :         firstkeyword = false;
    1865          36 :         appendPQExpBuffer(buf, "%s=", keywords[i]);
    1866          36 :         appendConnStrVal(buf, values[i]);
    1867             :     }
    1868             : 
    1869          30 :     connstr = pg_strdup(buf->data);
    1870          30 :     destroyPQExpBuffer(buf);
    1871          30 :     return connstr;
    1872             : }
    1873             : 
    1874             : /*
    1875             :  * Run a query, return the results, exit program on failure.
    1876             :  */
    1877             : static PGresult *
    1878         320 : executeQuery(PGconn *conn, const char *query)
    1879             : {
    1880             :     PGresult   *res;
    1881             : 
    1882         320 :     pg_log_info("executing %s", query);
    1883             : 
    1884         320 :     res = PQexec(conn, query);
    1885         640 :     if (!res ||
    1886         320 :         PQresultStatus(res) != PGRES_TUPLES_OK)
    1887             :     {
    1888           0 :         pg_log_error("query failed: %s", PQerrorMessage(conn));
    1889           0 :         pg_log_error("query was: %s", query);
    1890           0 :         PQfinish(conn);
    1891           0 :         exit_nicely(1);
    1892             :     }
    1893             : 
    1894         320 :     return res;
    1895             : }
    1896             : 
    1897             : /*
    1898             :  * As above for a SQL command (which returns nothing).
    1899             :  */
    1900             : static void
    1901           2 : executeCommand(PGconn *conn, const char *query)
    1902             : {
    1903             :     PGresult   *res;
    1904             : 
    1905           2 :     pg_log_info("executing %s", query);
    1906             : 
    1907           2 :     res = PQexec(conn, query);
    1908           4 :     if (!res ||
    1909           2 :         PQresultStatus(res) != PGRES_COMMAND_OK)
    1910             :     {
    1911           0 :         pg_log_error("query failed: %s", PQerrorMessage(conn));
    1912           0 :         pg_log_error("query was: %s", query);
    1913           0 :         PQfinish(conn);
    1914           0 :         exit_nicely(1);
    1915             :     }
    1916             : 
    1917           2 :     PQclear(res);
    1918           2 : }
    1919             : 
    1920             : 
    1921             : /*
    1922             :  * dumpTimestamp
    1923             :  */
    1924             : static void
    1925           8 : dumpTimestamp(const char *msg)
    1926             : {
    1927             :     char        buf[64];
    1928           8 :     time_t      now = time(NULL);
    1929             : 
    1930           8 :     if (strftime(buf, sizeof(buf), PGDUMP_STRFTIME_FMT, localtime(&now)) != 0)
    1931           8 :         fprintf(OPF, "-- %s %s\n\n", msg, buf);
    1932           8 : }

Generated by: LCOV version 1.13