/*------------------------------------------------------------------------- * * pg_regress --- regression test driver * * This is a C implementation of the previous shell script for running * the regression tests, and should be mostly compatible with it. * Initial author of C translation: Magnus Hagander * * This code is released under the terms of the PostgreSQL License. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * src/test/regress/pg_regress.c * *------------------------------------------------------------------------- */ #include "postgres_fe.h" #include #include #include #include #include #include #include #include "common/logging.h" #include "common/restricted_token.h" #include "common/username.h" #include "getopt_long.h" #include "lib/stringinfo.h" #include "libpq-fe.h" #include "libpq/pqcomm.h" /* needed for UNIXSOCK_PATH() */ #include "pg_config_paths.h" #include "pg_regress.h" #include "portability/instr_time.h" /* for resultmap we need a list of pairs of strings */ typedef struct _resultmap { char *test; char *type; char *resultfile; struct _resultmap *next; } _resultmap; /* * Values obtained from Makefile. */ char *host_platform = HOST_TUPLE; #ifndef WIN32 /* not used in WIN32 case */ static char *shellprog = SHELLPROG; #endif /* * On Windows we use -w in diff switches to avoid problems with inconsistent * newline representation. The actual result files will generally have * Windows-style newlines, but the comparison files might or might not. */ #ifndef WIN32 const char *basic_diff_opts = ""; const char *pretty_diff_opts = "-U3"; #else const char *basic_diff_opts = "--strip-trailing-cr"; const char *pretty_diff_opts = "--strip-trailing-cr -U3"; #endif /* * The width of the testname field when printing to ensure vertical alignment * of test runtimes. This number is somewhat arbitrarily chosen to match the * older pre-TAP output format. */ #define TESTNAME_WIDTH 36 /* * The number times per second that pg_regress checks to see if the test * instance server has started and is available for connection. */ #define WAIT_TICKS_PER_SECOND 20 typedef enum TAPtype { DIAG = 0, BAIL, NOTE, NOTE_DETAIL, NOTE_END, TEST_STATUS, PLAN, NONE, } TAPtype; /* options settable from command line */ _stringlist *dblist = NULL; bool debug = false; char *inputdir = "."; char *outputdir = "."; char *expecteddir = "."; char *bindir = PGBINDIR; char *launcher = NULL; static _stringlist *loadextension = NULL; static int max_connections = 0; static int max_concurrent_tests = 0; static char *encoding = NULL; static _stringlist *schedulelist = NULL; static _stringlist *extra_tests = NULL; static char *temp_instance = NULL; static _stringlist *temp_configs = NULL; static bool nolocale = false; static bool use_existing = false; static char *hostname = NULL; static int port = -1; static char portstr[16]; static bool port_specified_by_user = false; static char *dlpath = PKGLIBDIR; static char *user = NULL; static _stringlist *extraroles = NULL; static char *config_auth_datadir = NULL; /* internal variables */ static const char *progname; static char *logfilename; static FILE *logfile; static char *difffilename; static const char *sockdir; static const char *temp_sockdir; static char sockself[MAXPGPATH]; static char socklock[MAXPGPATH]; static StringInfo failed_tests = NULL; static bool in_note = false; static _resultmap *resultmap = NULL; static PID_TYPE postmaster_pid = INVALID_PID; static bool postmaster_running = false; static int success_count = 0; static int fail_count = 0; static bool directory_exists(const char *dir); static void make_directory(const char *dir); static void test_status_print(bool ok, const char *testname, double runtime, bool parallel); static void test_status_ok(const char *testname, double runtime, bool parallel); static void test_status_failed(const char *testname, double runtime, bool parallel); static void bail_out(bool noatexit, const char *fmt,...) pg_attribute_printf(2, 3); static void emit_tap_output(TAPtype type, const char *fmt,...) pg_attribute_printf(2, 3); static void emit_tap_output_v(TAPtype type, const char *fmt, va_list argp) pg_attribute_printf(2, 0); static StringInfo psql_start_command(void); static void psql_add_command(StringInfo buf, const char *query,...) pg_attribute_printf(2, 3); static void psql_end_command(StringInfo buf, const char *database); /* * Convenience macros for printing TAP output with a more shorthand syntax * aimed at making the code more readable. */ #define plan(x) emit_tap_output(PLAN, "1..%i", (x)) #define note(...) emit_tap_output(NOTE, __VA_ARGS__) #define note_detail(...) emit_tap_output(NOTE_DETAIL, __VA_ARGS__) #define diag(...) emit_tap_output(DIAG, __VA_ARGS__) #define note_end() emit_tap_output(NOTE_END, "\n"); #define bail_noatexit(...) bail_out(true, __VA_ARGS__) #define bail(...) bail_out(false, __VA_ARGS__) /* * allow core files if possible. */ #if defined(HAVE_GETRLIMIT) static void unlimit_core_size(void) { struct rlimit lim; getrlimit(RLIMIT_CORE, &lim); if (lim.rlim_max == 0) { diag("could not set core size: disallowed by hard limit"); return; } else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max) { lim.rlim_cur = lim.rlim_max; setrlimit(RLIMIT_CORE, &lim); } } #endif /* * Add an item at the end of a stringlist. */ void add_stringlist_item(_stringlist **listhead, const char *str) { _stringlist *newentry = pg_malloc(sizeof(_stringlist)); _stringlist *oldentry; newentry->str = pg_strdup(str); newentry->next = NULL; if (*listhead == NULL) *listhead = newentry; else { for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next) /* skip */ ; oldentry->next = newentry; } } /* * Free a stringlist. */ static void free_stringlist(_stringlist **listhead) { if (listhead == NULL || *listhead == NULL) return; if ((*listhead)->next != NULL) free_stringlist(&((*listhead)->next)); free((*listhead)->str); free(*listhead); *listhead = NULL; } /* * Split a delimited string into a stringlist */ static void split_to_stringlist(const char *s, const char *delim, _stringlist **listhead) { char *token; char *sc; char *tofree; tofree = sc = pg_strdup(s); while ((token = strsep(&sc, delim))) { add_stringlist_item(listhead, token); } free(tofree); } /* * Bailing out is for unrecoverable errors which prevents further testing to * occur and after which the test run should be aborted. By passing noatexit * as true the process will terminate with _exit(2) and skipping registered * exit handlers, thus avoid any risk of bottomless recursion calls to exit. */ static void bail_out(bool noatexit, const char *fmt,...) { va_list ap; va_start(ap, fmt); emit_tap_output_v(BAIL, fmt, ap); va_end(ap); if (noatexit) _exit(2); exit(2); } /* * Print the result of a test run and associated metadata like runtime. Care * is taken to align testnames and runtimes vertically to ensure the output * is human readable while still TAP compliant. Tests run in parallel are * prefixed with a '+' and sequential tests with a '-'. This distinction was * previously indicated by 'test' prefixing sequential tests while parallel * tests were indented by four leading spaces. The meson TAP parser consumes * leading space however, so a non-whitespace prefix of the same length is * required for both. */ static void test_status_print(bool ok, const char *testname, double runtime, bool parallel) { int testnumber = fail_count + success_count; /* * Testnumbers are padded to 5 characters to ensure that testnames align * vertically (assuming at most 9999 tests). Testnames are prefixed with * a leading character to indicate being run in parallel or not. A leading * '+' indicates a parallel test, '-' indicates a single test. */ emit_tap_output(TEST_STATUS, "%sok %-5i%*s %c %-*s %8.0f ms", (ok ? "" : "not "), testnumber, /* If ok, indent with four spaces matching "not " */ (ok ? (int) strlen("not ") : 0), "", /* Prefix a parallel test '+' and a single test with '-' */ (parallel ? '+' : '-'), /* Testnames are padded to align runtimes */ TESTNAME_WIDTH, testname, runtime); } static void test_status_ok(const char *testname, double runtime, bool parallel) { success_count++; test_status_print(true, testname, runtime, parallel); } static void test_status_failed(const char *testname, double runtime, bool parallel) { /* * Save failed tests in a buffer such that we can print a summary at the * end with diag() to ensure it's shown even under test harnesses. */ if (!failed_tests) failed_tests = makeStringInfo(); else appendStringInfoChar(failed_tests, ','); appendStringInfo(failed_tests, " %s", testname); fail_count++; test_status_print(false, testname, runtime, parallel); } static void emit_tap_output(TAPtype type, const char *fmt,...) { va_list argp; va_start(argp, fmt); emit_tap_output_v(type, fmt, argp); va_end(argp); } static void emit_tap_output_v(TAPtype type, const char *fmt, va_list argp) { va_list argp_logfile; FILE *fp; int save_errno; /* * The fprintf() calls used to output TAP-protocol elements might clobber * errno, so save it here and restore it before vfprintf()-ing the user's * format string, in case it contains %m placeholders. */ save_errno = errno; /* * Diagnostic output will be hidden by prove unless printed to stderr. The * Bail message is also printed to stderr to aid debugging under a harness * which might otherwise not emit such an important message. */ if (type == DIAG || type == BAIL) fp = stderr; else fp = stdout; /* * If we are ending a note_detail line we can avoid further processing and * immediately return following a newline. */ if (type == NOTE_END) { in_note = false; fprintf(fp, "\n"); if (logfile) fprintf(logfile, "\n"); return; } /* Make a copy of the va args for printing to the logfile */ va_copy(argp_logfile, argp); /* * Non-protocol output such as diagnostics or notes must be prefixed by a * '#' character. We print the Bail message like this too. */ if ((type == NOTE || type == DIAG || type == BAIL) || (type == NOTE_DETAIL && !in_note)) { fprintf(fp, "# "); if (logfile) fprintf(logfile, "# "); } errno = save_errno; vfprintf(fp, fmt, argp); if (logfile) { errno = save_errno; vfprintf(logfile, fmt, argp_logfile); } /* * If we are entering into a note with more details to follow, register * that the leading '#' has been printed such that subsequent details * aren't prefixed as well. */ if (type == NOTE_DETAIL) in_note = true; /* * If this was a Bail message, the bail protocol message must go to stdout * separately. */ if (type == BAIL) { fprintf(stdout, "Bail out!"); if (logfile) fprintf(logfile, "Bail out!"); } va_end(argp_logfile); if (type != NOTE_DETAIL) { fprintf(fp, "\n"); if (logfile) fprintf(logfile, "\n"); } fflush(NULL); } /* * shut down temp postmaster */ static void stop_postmaster(void) { if (postmaster_running) { /* We use pg_ctl to issue the kill and wait for stop */ char buf[MAXPGPATH * 2]; int r; snprintf(buf, sizeof(buf), "\"%s%spg_ctl\" stop -D \"%s/data\" -s", bindir ? bindir : "", bindir ? "/" : "", temp_instance); fflush(NULL); r = system(buf); if (r != 0) { /* Not using the normal bail() as we want _exit */ bail_noatexit(_("could not stop postmaster: exit code was %d"), r); } postmaster_running = false; } } /* * Remove the socket temporary directory. pg_regress never waits for a * postmaster exit, so it is indeterminate whether the postmaster has yet to * unlink the socket and lock file. Unlink them here so we can proceed to * remove the directory. Ignore errors; leaking a temporary directory is * unimportant. This can run from a signal handler. The code is not * acceptable in a Windows signal handler (see initdb.c:trapsig()), but * on Windows, pg_regress does not use Unix sockets by default. */ static void remove_temp(void) { Assert(temp_sockdir); unlink(sockself); unlink(socklock); rmdir(temp_sockdir); } /* * Signal handler that calls remove_temp() and reraises the signal. */ static void signal_remove_temp(SIGNAL_ARGS) { remove_temp(); pqsignal(postgres_signal_arg, SIG_DFL); raise(postgres_signal_arg); } /* * Create a temporary directory suitable for the server's Unix-domain socket. * The directory will have mode 0700 or stricter, so no other OS user can open * our socket to exploit our use of trust authentication. Most systems * constrain the length of socket paths well below _POSIX_PATH_MAX, so we * place the directory under /tmp rather than relative to the possibly-deep * current working directory. * * Compared to using the compiled-in DEFAULT_PGSOCKET_DIR, this also permits * testing to work in builds that relocate it to a directory not writable to * the build/test user. */ static const char * make_temp_sockdir(void) { char *template = psprintf("%s/pg_regress-XXXXXX", getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp"); temp_sockdir = mkdtemp(template); if (temp_sockdir == NULL) bail("could not create directory \"%s\": %m", template); /* Stage file names for remove_temp(). Unsafe in a signal handler. */ UNIXSOCK_PATH(sockself, port, temp_sockdir); snprintf(socklock, sizeof(socklock), "%s.lock", sockself); /* Remove the directory during clean exit. */ atexit(remove_temp); /* * Remove the directory before dying to the usual signals. Omit SIGQUIT, * preserving it as a quick, untidy exit. */ pqsignal(SIGINT, signal_remove_temp); pqsignal(SIGTERM, signal_remove_temp); /* the following are not valid on Windows */ #ifndef WIN32 pqsignal(SIGHUP, signal_remove_temp); pqsignal(SIGPIPE, signal_remove_temp); #endif return temp_sockdir; } /* * Check whether string matches pattern * * In the original shell script, this function was implemented using expr(1), * which provides basic regular expressions restricted to match starting at * the string start (in conventional regex terms, there's an implicit "^" * at the start of the pattern --- but no implicit "$" at the end). * * For now, we only support "." and ".*" as non-literal metacharacters, * because that's all that anyone has found use for in resultmap. This * code could be extended if more functionality is needed. */ static bool string_matches_pattern(const char *str, const char *pattern) { while (*str && *pattern) { if (*pattern == '.' && pattern[1] == '*') { pattern += 2; /* Trailing .* matches everything. */ if (*pattern == '\0') return true; /* * Otherwise, scan for a text position at which we can match the * rest of the pattern. */ while (*str) { /* * Optimization to prevent most recursion: don't recurse * unless first pattern char might match this text char. */ if (*str == *pattern || *pattern == '.') { if (string_matches_pattern(str, pattern)) return true; } str++; } /* * End of text with no match. */ return false; } else if (*pattern != '.' && *str != *pattern) { /* * Not the single-character wildcard and no explicit match? Then * time to quit... */ return false; } str++; pattern++; } if (*pattern == '\0') return true; /* end of pattern, so declare match */ /* End of input string. Do we have matching pattern remaining? */ while (*pattern == '.' && pattern[1] == '*') pattern += 2; if (*pattern == '\0') return true; /* end of pattern, so declare match */ return false; } /* * Scan resultmap file to find which platform-specific expected files to use. * * The format of each line of the file is * testname/hostplatformpattern=substitutefile * where the hostplatformpattern is evaluated per the rules of expr(1), * namely, it is a standard regular expression with an implicit ^ at the start. * (We currently support only a very limited subset of regular expressions, * see string_matches_pattern() above.) What hostplatformpattern will be * matched against is the config.guess output. (In the shell-script version, * we also provided an indication of whether gcc or another compiler was in * use, but that facility isn't used anymore.) */ static void load_resultmap(void) { char buf[MAXPGPATH]; FILE *f; /* scan the file ... */ snprintf(buf, sizeof(buf), "%s/resultmap", inputdir); f = fopen(buf, "r"); if (!f) { /* OK if it doesn't exist, else complain */ if (errno == ENOENT) return; bail("could not open file \"%s\" for reading: %m", buf); } while (fgets(buf, sizeof(buf), f)) { char *platform; char *file_type; char *expected; int i; /* strip trailing whitespace, especially the newline */ i = strlen(buf); while (i > 0 && isspace((unsigned char) buf[i - 1])) buf[--i] = '\0'; /* parse out the line fields */ file_type = strchr(buf, ':'); if (!file_type) { bail("incorrectly formatted resultmap entry: %s", buf); } *file_type++ = '\0'; platform = strchr(file_type, ':'); if (!platform) { bail("incorrectly formatted resultmap entry: %s", buf); } *platform++ = '\0'; expected = strchr(platform, '='); if (!expected) { bail("incorrectly formatted resultmap entry: %s", buf); } *expected++ = '\0'; /* * if it's for current platform, save it in resultmap list. Note: by * adding at the front of the list, we ensure that in ambiguous cases, * the last match in the resultmap file is used. This mimics the * behavior of the old shell script. */ if (string_matches_pattern(host_platform, platform)) { _resultmap *entry = pg_malloc(sizeof(_resultmap)); entry->test = pg_strdup(buf); entry->type = pg_strdup(file_type); entry->resultfile = pg_strdup(expected); entry->next = resultmap; resultmap = entry; } } fclose(f); } /* * Check in resultmap if we should be looking at a different file */ static const char * get_expectfile(const char *testname, const char *file) { char *file_type; _resultmap *rm; /* * Determine the file type from the file name. This is just what is * following the last dot in the file name. */ if (!file || !(file_type = strrchr(file, '.'))) return NULL; file_type++; for (rm = resultmap; rm != NULL; rm = rm->next) { if (strcmp(testname, rm->test) == 0 && strcmp(file_type, rm->type) == 0) { return rm->resultfile; } } return NULL; } /* * Prepare environment variables for running regression tests */ static void initialize_environment(void) { /* * Set default application_name. (The test_start_function may choose to * override this, but if it doesn't, we have something useful in place.) */ setenv("PGAPPNAME", "pg_regress", 1); /* * Set variables that the test scripts may need to refer to. */ setenv("PG_ABS_SRCDIR", inputdir, 1); setenv("PG_ABS_BUILDDIR", outputdir, 1); setenv("PG_LIBDIR", dlpath, 1); setenv("PG_DLSUFFIX", DLSUFFIX, 1); if (nolocale) { /* * Clear out any non-C locale settings */ unsetenv("LC_COLLATE"); unsetenv("LC_CTYPE"); unsetenv("LC_MONETARY"); unsetenv("LC_NUMERIC"); unsetenv("LC_TIME"); unsetenv("LANG"); /* * Most platforms have adopted the POSIX locale as their * implementation-defined default locale. Exceptions include native * Windows, macOS with --enable-nls, and Cygwin with --enable-nls. * (Use of --enable-nls matters because libintl replaces setlocale().) * Also, PostgreSQL does not support macOS with locale environment * variables unset; see PostmasterMain(). */ #if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__) setenv("LANG", "C", 1); #endif } /* * Set translation-related settings to English; otherwise psql will * produce translated messages and produce diffs. (XXX If we ever support * translation of pg_regress, this needs to be moved elsewhere, where psql * is actually called.) */ unsetenv("LANGUAGE"); unsetenv("LC_ALL"); setenv("LC_MESSAGES", "C", 1); /* * Set encoding as requested */ if (encoding) setenv("PGCLIENTENCODING", encoding, 1); else unsetenv("PGCLIENTENCODING"); /* * Set timezone and datestyle for datetime-related tests */ setenv("PGTZ", "America/Los_Angeles", 1); setenv("PGDATESTYLE", "Postgres, MDY", 1); /* * Likewise set intervalstyle to ensure consistent results. This is a bit * more painful because we must use PGOPTIONS, and we want to preserve the * user's ability to set other variables through that. */ { const char *my_pgoptions = "-c intervalstyle=postgres_verbose"; const char *old_pgoptions = getenv("PGOPTIONS"); char *new_pgoptions; if (!old_pgoptions) old_pgoptions = ""; new_pgoptions = psprintf("%s %s", old_pgoptions, my_pgoptions); setenv("PGOPTIONS", new_pgoptions, 1); free(new_pgoptions); } if (temp_instance) { /* * Clear out any environment vars that might cause psql to connect to * the wrong postmaster, or otherwise behave in nondefault ways. (Note * we also use psql's -X switch consistently, so that ~/.psqlrc files * won't mess things up.) Also, set PGPORT to the temp port, and set * PGHOST depending on whether we are using TCP or Unix sockets. * * This list should be kept in sync with PostgreSQL/Test/Utils.pm. */ unsetenv("PGCHANNELBINDING"); /* PGCLIENTENCODING, see above */ unsetenv("PGCONNECT_TIMEOUT"); unsetenv("PGDATA"); unsetenv("PGDATABASE"); unsetenv("PGGSSDELEGATION"); unsetenv("PGGSSENCMODE"); unsetenv("PGGSSLIB"); /* PGHOSTADDR, see below */ unsetenv("PGKRBSRVNAME"); unsetenv("PGPASSFILE"); unsetenv("PGPASSWORD"); unsetenv("PGREQUIREPEER"); unsetenv("PGREQUIRESSL"); unsetenv("PGSERVICE"); unsetenv("PGSERVICEFILE"); unsetenv("PGSSLCERT"); unsetenv("PGSSLCRL"); unsetenv("PGSSLCRLDIR"); unsetenv("PGSSLKEY"); unsetenv("PGSSLMAXPROTOCOLVERSION"); unsetenv("PGSSLMINPROTOCOLVERSION"); unsetenv("PGSSLMODE"); unsetenv("PGSSLROOTCERT"); unsetenv("PGSSLSNI"); unsetenv("PGTARGETSESSIONATTRS"); unsetenv("PGUSER"); /* PGPORT, see below */ /* PGHOST, see below */ if (hostname != NULL) setenv("PGHOST", hostname, 1); else { sockdir = getenv("PG_REGRESS_SOCK_DIR"); if (!sockdir) sockdir = make_temp_sockdir(); setenv("PGHOST", sockdir, 1); } unsetenv("PGHOSTADDR"); if (port != -1) { char s[16]; snprintf(s, sizeof(s), "%d", port); setenv("PGPORT", s, 1); } } else { const char *pghost; const char *pgport; /* * When testing an existing install, we honor existing environment * variables, except if they're overridden by command line options. */ if (hostname != NULL) { setenv("PGHOST", hostname, 1); unsetenv("PGHOSTADDR"); } if (port != -1) { char s[16]; snprintf(s, sizeof(s), "%d", port); setenv("PGPORT", s, 1); } if (user != NULL) setenv("PGUSER", user, 1); /* * However, we *don't* honor PGDATABASE, since we certainly don't wish * to connect to whatever database the user might like as default. * (Most tests override PGDATABASE anyway, but there are some ECPG * test cases that don't.) */ unsetenv("PGDATABASE"); /* * Report what we're connecting to */ pghost = getenv("PGHOST"); pgport = getenv("PGPORT"); if (!pghost) { /* Keep this bit in sync with libpq's default host location: */ if (DEFAULT_PGSOCKET_DIR[0]) /* do nothing, we'll print "Unix socket" below */ ; else pghost = "localhost"; /* DefaultHost in fe-connect.c */ } if (pghost && pgport) note("using postmaster on %s, port %s", pghost, pgport); if (pghost && !pgport) note("using postmaster on %s, default port", pghost); if (!pghost && pgport) note("using postmaster on Unix socket, port %s", pgport); if (!pghost && !pgport) note("using postmaster on Unix socket, default port"); } load_resultmap(); } #ifdef ENABLE_SSPI /* support for config_sspi_auth() */ static const char * fmtHba(const char *raw) { static char *ret; const char *rp; char *wp; wp = ret = pg_realloc(ret, 3 + strlen(raw) * 2); *wp++ = '"'; for (rp = raw; *rp; rp++) { if (*rp == '"') *wp++ = '"'; *wp++ = *rp; } *wp++ = '"'; *wp++ = '\0'; return ret; } /* * Get account and domain/realm names for the current user. This is based on * pg_SSPI_recvauth(). The returned strings use static storage. */ static void current_windows_user(const char **acct, const char **dom) { static char accountname[MAXPGPATH]; static char domainname[MAXPGPATH]; HANDLE token; TOKEN_USER *tokenuser; DWORD retlen; DWORD accountnamesize = sizeof(accountname); DWORD domainnamesize = sizeof(domainname); SID_NAME_USE accountnameuse; if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token)) { bail("could not open process token: error code %lu", GetLastError()); } if (!GetTokenInformation(token, TokenUser, NULL, 0, &retlen) && GetLastError() != 122) { bail("could not get token information buffer size: error code %lu", GetLastError()); } tokenuser = pg_malloc(retlen); if (!GetTokenInformation(token, TokenUser, tokenuser, retlen, &retlen)) { bail("could not get token information: error code %lu", GetLastError()); } if (!LookupAccountSid(NULL, tokenuser->User.Sid, accountname, &accountnamesize, domainname, &domainnamesize, &accountnameuse)) { bail("could not look up account SID: error code %lu", GetLastError()); } free(tokenuser); *acct = accountname; *dom = domainname; } /* * Rewrite pg_hba.conf and pg_ident.conf to use SSPI authentication. Permit * the current OS user to authenticate as the bootstrap superuser and as any * user named in a --create-role option. * * In --config-auth mode, the --user switch can be used to specify the * bootstrap superuser's name, otherwise we assume it is the default. */ static void config_sspi_auth(const char *pgdata, const char *superuser_name) { const char *accountname, *domainname; char *errstr; bool have_ipv6; char fname[MAXPGPATH]; int res; FILE *hba, *ident; _stringlist *sl; /* Find out the name of the current OS user */ current_windows_user(&accountname, &domainname); /* Determine the bootstrap superuser's name */ if (superuser_name == NULL) { /* * Compute the default superuser name the same way initdb does. * * It's possible that this result always matches "accountname", the * value SSPI authentication discovers. But the underlying system * functions do not clearly guarantee that. */ superuser_name = get_user_name(&errstr); if (superuser_name == NULL) { bail("%s", errstr); } } /* * Like initdb.c:setup_config(), determine whether the platform recognizes * ::1 (IPv6 loopback) as a numeric host address string. */ { struct addrinfo *gai_result; struct addrinfo hints; WSADATA wsaData; hints.ai_flags = AI_NUMERICHOST; hints.ai_family = AF_UNSPEC; hints.ai_socktype = 0; hints.ai_protocol = 0; hints.ai_addrlen = 0; hints.ai_canonname = NULL; hints.ai_addr = NULL; hints.ai_next = NULL; have_ipv6 = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0 && getaddrinfo("::1", NULL, &hints, &gai_result) == 0); } /* Check a Write outcome and report any error. */ #define CW(cond) \ do { \ if (!(cond)) \ bail("could not write to file \"%s\": %m", fname); \ } while (0) res = snprintf(fname, sizeof(fname), "%s/pg_hba.conf", pgdata); if (res < 0 || res >= sizeof(fname)) { /* * Truncating this name is a fatal error, because we must not fail to * overwrite an original trust-authentication pg_hba.conf. */ bail("directory name too long"); } hba = fopen(fname, "w"); if (hba == NULL) { bail("could not open file \"%s\" for writing: %m", fname); } CW(fputs("# Configuration written by config_sspi_auth()\n", hba) >= 0); CW(fputs("host all all 127.0.0.1/32 sspi include_realm=1 map=regress\n", hba) >= 0); if (have_ipv6) CW(fputs("host all all ::1/128 sspi include_realm=1 map=regress\n", hba) >= 0); CW(fclose(hba) == 0); snprintf(fname, sizeof(fname), "%s/pg_ident.conf", pgdata); ident = fopen(fname, "w"); if (ident == NULL) { bail("could not open file \"%s\" for writing: %m", fname); } CW(fputs("# Configuration written by config_sspi_auth()\n", ident) >= 0); /* * Double-quote for the benefit of account names containing whitespace or * '#'. Windows forbids the double-quote character itself, so don't * bother escaping embedded double-quote characters. */ CW(fprintf(ident, "regress \"%s@%s\" %s\n", accountname, domainname, fmtHba(superuser_name)) >= 0); for (sl = extraroles; sl; sl = sl->next) CW(fprintf(ident, "regress \"%s@%s\" %s\n", accountname, domainname, fmtHba(sl->str)) >= 0); CW(fclose(ident) == 0); } #endif /* ENABLE_SSPI */ /* * psql_start_command, psql_add_command, psql_end_command * * Issue one or more commands within one psql call. * Set up with psql_start_command, then add commands one at a time * with psql_add_command, and finally execute with psql_end_command. * * Since we use system(), this doesn't return until the operation finishes */ static StringInfo psql_start_command(void) { StringInfo buf = makeStringInfo(); appendStringInfo(buf, "\"%s%spsql\" -X -q", bindir ? bindir : "", bindir ? "/" : ""); return buf; } static void psql_add_command(StringInfo buf, const char *query,...) { StringInfoData cmdbuf; const char *cmdptr; /* Add each command as a -c argument in the psql call */ appendStringInfoString(buf, " -c \""); /* Generate the query with insertion of sprintf arguments */ initStringInfo(&cmdbuf); for (;;) { va_list args; int needed; va_start(args, query); needed = appendStringInfoVA(&cmdbuf, query, args); va_end(args); if (needed == 0) break; /* success */ enlargeStringInfo(&cmdbuf, needed); } /* Now escape any shell double-quote metacharacters */ for (cmdptr = cmdbuf.data; *cmdptr; cmdptr++) { if (strchr("\\\"$`", *cmdptr)) appendStringInfoChar(buf, '\\'); appendStringInfoChar(buf, *cmdptr); } appendStringInfoChar(buf, '"'); pfree(cmdbuf.data); } static void psql_end_command(StringInfo buf, const char *database) { /* Add the database name --- assume it needs no extra escaping */ appendStringInfo(buf, " \"%s\"", database); /* And now we can execute the shell command */ fflush(NULL); if (system(buf->data) != 0) { /* psql probably already reported the error */ bail("command failed: %s", buf->data); } /* Clean up */ destroyStringInfo(buf); } /* * Shorthand macro for the common case of a single command */ #define psql_command(database, ...) \ do { \ StringInfo cmdbuf = psql_start_command(); \ psql_add_command(cmdbuf, __VA_ARGS__); \ psql_end_command(cmdbuf, database); \ } while (0) /* * Spawn a process to execute the given shell command; don't wait for it * * Returns the process ID (or HANDLE) so we can wait for it later */ PID_TYPE spawn_process(const char *cmdline) { #ifndef WIN32 pid_t pid; /* * Must flush I/O buffers before fork. */ fflush(NULL); #ifdef EXEC_BACKEND pg_disable_aslr(); #endif pid = fork(); if (pid == -1) { bail("could not fork: %m"); } if (pid == 0) { /* * In child * * Instead of using system(), exec the shell directly, and tell it to * "exec" the command too. This saves two useless processes per * parallel test case. */ char *cmdline2; cmdline2 = psprintf("exec %s", cmdline); execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL); /* Not using the normal bail() here as we want _exit */ bail_noatexit("could not exec \"%s\": %m", shellprog); } /* in parent */ return pid; #else PROCESS_INFORMATION pi; char *cmdline2; const char *comspec; /* Find CMD.EXE location using COMSPEC, if it's set */ comspec = getenv("COMSPEC"); if (comspec == NULL) comspec = "CMD"; memset(&pi, 0, sizeof(pi)); cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline); if (!CreateRestrictedProcess(cmdline2, &pi)) exit(2); CloseHandle(pi.hThread); return pi.hProcess; #endif } /* * Count bytes in file */ static long file_size(const char *file) { long r; FILE *f = fopen(file, "r"); if (!f) { diag("could not open file \"%s\" for reading: %m", file); return -1; } fseek(f, 0, SEEK_END); r = ftell(f); fclose(f); return r; } /* * Count lines in file */ static int file_line_count(const char *file) { int c; int l = 0; FILE *f = fopen(file, "r"); if (!f) { diag("could not open file \"%s\" for reading: %m", file); return -1; } while ((c = fgetc(f)) != EOF) { if (c == '\n') l++; } fclose(f); return l; } bool file_exists(const char *file) { FILE *f = fopen(file, "r"); if (!f) return false; fclose(f); return true; } static bool directory_exists(const char *dir) { struct stat st; if (stat(dir, &st) != 0) return false; if (S_ISDIR(st.st_mode)) return true; return false; } /* Create a directory */ static void make_directory(const char *dir) { if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0) bail("could not create directory \"%s\": %m", dir); } /* * In: filename.ext, Return: filename_i.ext, where 0 <= i <= 9 */ static char * get_alternative_expectfile(const char *expectfile, int i) { char *last_dot; int ssize = strlen(expectfile) + 2 + 1; char *tmp; char *s; if (!(tmp = (char *) malloc(ssize))) return NULL; if (!(s = (char *) malloc(ssize))) { free(tmp); return NULL; } strcpy(tmp, expectfile); last_dot = strrchr(tmp, '.'); if (!last_dot) { free(tmp); free(s); return NULL; } *last_dot = '\0'; snprintf(s, ssize, "%s_%d.%s", tmp, i, last_dot + 1); free(tmp); return s; } /* * Run a "diff" command and also check that it didn't crash */ static int run_diff(const char *cmd, const char *filename) { int r; fflush(NULL); r = system(cmd); if (!WIFEXITED(r) || WEXITSTATUS(r) > 1) { bail("diff command failed with status %d: %s", r, cmd); } #ifdef WIN32 /* * On WIN32, if the 'diff' command cannot be found, system() returns 1, * but produces nothing to stdout, so we check for that here. */ if (WEXITSTATUS(r) == 1 && file_size(filename) <= 0) { bail("diff command not found: %s", cmd); } #endif return WEXITSTATUS(r); } /* * Check the actual result file for the given test against expected results * * Returns true if different (failure), false if correct match found. * In the true case, the diff is appended to the diffs file. */ static bool results_differ(const char *testname, const char *resultsfile, const char *default_expectfile) { char expectfile[MAXPGPATH]; char diff[MAXPGPATH]; char cmd[MAXPGPATH * 3]; char best_expect_file[MAXPGPATH]; FILE *difffile; int best_line_count; int i; int l; const char *platform_expectfile; /* * We can pass either the resultsfile or the expectfile, they should have * the same type (filename.type) anyway. */ platform_expectfile = get_expectfile(testname, resultsfile); strlcpy(expectfile, default_expectfile, sizeof(expectfile)); if (platform_expectfile) { /* * Replace everything after the last slash in expectfile with what the * platform_expectfile contains. */ char *p = strrchr(expectfile, '/'); if (p) strcpy(++p, platform_expectfile); } /* Name to use for temporary diff file */ snprintf(diff, sizeof(diff), "%s.diff", resultsfile); /* OK, run the diff */ snprintf(cmd, sizeof(cmd), "diff %s \"%s\" \"%s\" > \"%s\"", basic_diff_opts, expectfile, resultsfile, diff); /* Is the diff file empty? */ if (run_diff(cmd, diff) == 0) { unlink(diff); return false; } /* There may be secondary comparison files that match better */ best_line_count = file_line_count(diff); strcpy(best_expect_file, expectfile); for (i = 0; i <= 9; i++) { char *alt_expectfile; alt_expectfile = get_alternative_expectfile(expectfile, i); if (!alt_expectfile) bail("Unable to check secondary comparison files: %m"); if (!file_exists(alt_expectfile)) { free(alt_expectfile); continue; } snprintf(cmd, sizeof(cmd), "diff %s \"%s\" \"%s\" > \"%s\"", basic_diff_opts, alt_expectfile, resultsfile, diff); if (run_diff(cmd, diff) == 0) { unlink(diff); free(alt_expectfile); return false; } l = file_line_count(diff); if (l < best_line_count) { /* This diff was a better match than the last one */ best_line_count = l; strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file)); } free(alt_expectfile); } /* * fall back on the canonical results file if we haven't tried it yet and * haven't found a complete match yet. */ if (platform_expectfile) { snprintf(cmd, sizeof(cmd), "diff %s \"%s\" \"%s\" > \"%s\"", basic_diff_opts, default_expectfile, resultsfile, diff); if (run_diff(cmd, diff) == 0) { /* No diff = no changes = good */ unlink(diff); return false; } l = file_line_count(diff); if (l < best_line_count) { /* This diff was a better match than the last one */ best_line_count = l; strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file)); } } /* * Use the best comparison file to generate the "pretty" diff, which we * append to the diffs summary file. */ /* Write diff header */ difffile = fopen(difffilename, "a"); if (difffile) { fprintf(difffile, "diff %s %s %s\n", pretty_diff_opts, best_expect_file, resultsfile); fclose(difffile); } /* Run diff */ snprintf(cmd, sizeof(cmd), "diff %s \"%s\" \"%s\" >> \"%s\"", pretty_diff_opts, best_expect_file, resultsfile, difffilename); run_diff(cmd, difffilename); unlink(diff); return true; } /* * Wait for specified subprocesses to finish, and return their exit * statuses into statuses[] and stop times into stoptimes[] * * If names isn't NULL, print each subprocess's name as it finishes * * Note: it's OK to scribble on the pids array, but not on the names array */ static void wait_for_tests(PID_TYPE * pids, int *statuses, instr_time *stoptimes, char **names, int num_tests) { int tests_left; int i; #ifdef WIN32 PID_TYPE *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE)); memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE)); #endif tests_left = num_tests; while (tests_left > 0) { PID_TYPE p; #ifndef WIN32 int exit_status; p = wait(&exit_status); if (p == INVALID_PID) bail("failed to wait for subprocesses: %m"); #else DWORD exit_status; int r; r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE); if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left) { bail("failed to wait for subprocesses: error code %lu", GetLastError()); } p = active_pids[r - WAIT_OBJECT_0]; /* compact the active_pids array */ active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1]; #endif /* WIN32 */ for (i = 0; i < num_tests; i++) { if (p == pids[i]) { #ifdef WIN32 GetExitCodeProcess(pids[i], &exit_status); CloseHandle(pids[i]); #endif pids[i] = INVALID_PID; statuses[i] = (int) exit_status; INSTR_TIME_SET_CURRENT(stoptimes[i]); if (names) note_detail(" %s", names[i]); tests_left--; break; } } } #ifdef WIN32 free(active_pids); #endif } /* * report nonzero exit code from a test process */ static void log_child_failure(int exitstatus) { if (WIFEXITED(exitstatus)) diag("(test process exited with exit code %d)", WEXITSTATUS(exitstatus)); else if (WIFSIGNALED(exitstatus)) { #if defined(WIN32) diag("(test process was terminated by exception 0x%X)", WTERMSIG(exitstatus)); #else diag("(test process was terminated by signal %d: %s)", WTERMSIG(exitstatus), pg_strsignal(WTERMSIG(exitstatus))); #endif } else diag("(test process exited with unrecognized status %d)", exitstatus); } /* * Run all the tests specified in one schedule file */ static void run_schedule(const char *schedule, test_start_function startfunc, postprocess_result_function postfunc) { #define MAX_PARALLEL_TESTS 100 char *tests[MAX_PARALLEL_TESTS]; _stringlist *resultfiles[MAX_PARALLEL_TESTS]; _stringlist *expectfiles[MAX_PARALLEL_TESTS]; _stringlist *tags[MAX_PARALLEL_TESTS]; PID_TYPE pids[MAX_PARALLEL_TESTS]; instr_time starttimes[MAX_PARALLEL_TESTS]; instr_time stoptimes[MAX_PARALLEL_TESTS]; int statuses[MAX_PARALLEL_TESTS]; char scbuf[1024]; FILE *scf; int line_num = 0; memset(tests, 0, sizeof(tests)); memset(resultfiles, 0, sizeof(resultfiles)); memset(expectfiles, 0, sizeof(expectfiles)); memset(tags, 0, sizeof(tags)); scf = fopen(schedule, "r"); if (!scf) bail("could not open file \"%s\" for reading: %m", schedule); while (fgets(scbuf, sizeof(scbuf), scf)) { char *test = NULL; char *c; int num_tests; bool inword; int i; line_num++; /* strip trailing whitespace, especially the newline */ i = strlen(scbuf); while (i > 0 && isspace((unsigned char) scbuf[i - 1])) scbuf[--i] = '\0'; if (scbuf[0] == '\0' || scbuf[0] == '#') continue; if (strncmp(scbuf, "test: ", 6) == 0) test = scbuf + 6; else { bail("syntax error in schedule file \"%s\" line %d: %s", schedule, line_num, scbuf); } num_tests = 0; inword = false; for (c = test;; c++) { if (*c == '\0' || isspace((unsigned char) *c)) { if (inword) { /* Reached end of a test name */ char sav; if (num_tests >= MAX_PARALLEL_TESTS) { bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s", MAX_PARALLEL_TESTS, schedule, line_num, scbuf); } sav = *c; *c = '\0'; tests[num_tests] = pg_strdup(test); num_tests++; *c = sav; inword = false; } if (*c == '\0') break; /* loop exit is here */ } else if (!inword) { /* Start of a test name */ test = c; inword = true; } } if (num_tests == 0) { bail("syntax error in schedule file \"%s\" line %d: %s", schedule, line_num, scbuf); } if (num_tests == 1) { pids[0] = (startfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]); INSTR_TIME_SET_CURRENT(starttimes[0]); wait_for_tests(pids, statuses, stoptimes, NULL, 1); /* status line is finished below */ } else if (max_concurrent_tests > 0 && max_concurrent_tests < num_tests) { bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s", max_concurrent_tests, schedule, line_num, scbuf); } else if (max_connections > 0 && max_connections < num_tests) { int oldest = 0; note_detail("parallel group (%d tests, in groups of %d): ", num_tests, max_connections); for (i = 0; i < num_tests; i++) { if (i - oldest >= max_connections) { wait_for_tests(pids + oldest, statuses + oldest, stoptimes + oldest, tests + oldest, i - oldest); oldest = i; } pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]); INSTR_TIME_SET_CURRENT(starttimes[i]); } wait_for_tests(pids + oldest, statuses + oldest, stoptimes + oldest, tests + oldest, i - oldest); note_end(); } else { note_detail("parallel group (%d tests): ", num_tests); for (i = 0; i < num_tests; i++) { pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]); INSTR_TIME_SET_CURRENT(starttimes[i]); } wait_for_tests(pids, statuses, stoptimes, tests, num_tests); note_end(); } /* Check results for all tests */ for (i = 0; i < num_tests; i++) { _stringlist *rl, *el, *tl; bool differ = false; INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[i]); /* * Advance over all three lists simultaneously. * * Compare resultfiles[j] with expectfiles[j] always. Tags are * optional but if there are tags, the tag list has the same * length as the other two lists. */ for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i]; rl != NULL; /* rl and el have the same length */ rl = rl->next, el = el->next, tl = tl ? tl->next : NULL) { bool newdiff; if (postfunc) (*postfunc) (rl->str); newdiff = results_differ(tests[i], rl->str, el->str); if (newdiff && tl) { diag("tag: %s", tl->str); } differ |= newdiff; } if (statuses[i] != 0) { test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1)); log_child_failure(statuses[i]); } else { if (differ) { test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1)); } else { test_status_ok(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1)); } } } for (i = 0; i < num_tests; i++) { pg_free(tests[i]); tests[i] = NULL; free_stringlist(&resultfiles[i]); free_stringlist(&expectfiles[i]); free_stringlist(&tags[i]); } } fclose(scf); } /* * Run a single test */ static void run_single_test(const char *test, test_start_function startfunc, postprocess_result_function postfunc) { PID_TYPE pid; instr_time starttime; instr_time stoptime; int exit_status; _stringlist *resultfiles = NULL; _stringlist *expectfiles = NULL; _stringlist *tags = NULL; _stringlist *rl, *el, *tl; bool differ = false; pid = (startfunc) (test, &resultfiles, &expectfiles, &tags); INSTR_TIME_SET_CURRENT(starttime); wait_for_tests(&pid, &exit_status, &stoptime, NULL, 1); /* * Advance over all three lists simultaneously. * * Compare resultfiles[j] with expectfiles[j] always. Tags are optional * but if there are tags, the tag list has the same length as the other * two lists. */ for (rl = resultfiles, el = expectfiles, tl = tags; rl != NULL; /* rl and el have the same length */ rl = rl->next, el = el->next, tl = tl ? tl->next : NULL) { bool newdiff; if (postfunc) (*postfunc) (rl->str); newdiff = results_differ(test, rl->str, el->str); if (newdiff && tl) { diag("tag: %s", tl->str); } differ |= newdiff; } INSTR_TIME_SUBTRACT(stoptime, starttime); if (exit_status != 0) { test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false); log_child_failure(exit_status); } else { if (differ) { test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false); } else { test_status_ok(test, INSTR_TIME_GET_MILLISEC(stoptime), false); } } } /* * Create the summary-output files (making them empty if already existing) */ static void open_result_files(void) { char file[MAXPGPATH]; FILE *difffile; /* create outputdir directory if not present */ if (!directory_exists(outputdir)) make_directory(outputdir); /* create the log file (copy of running status output) */ snprintf(file, sizeof(file), "%s/regression.out", outputdir); logfilename = pg_strdup(file); logfile = fopen(logfilename, "w"); if (!logfile) bail("could not open file \"%s\" for writing: %m", logfilename); /* create the diffs file as empty */ snprintf(file, sizeof(file), "%s/regression.diffs", outputdir); difffilename = pg_strdup(file); difffile = fopen(difffilename, "w"); if (!difffile) bail("could not open file \"%s\" for writing: %m", difffilename); /* we don't keep the diffs file open continuously */ fclose(difffile); /* also create the results directory if not present */ snprintf(file, sizeof(file), "%s/results", outputdir); if (!directory_exists(file)) make_directory(file); } static void drop_database_if_exists(const char *dbname) { StringInfo buf = psql_start_command(); /* Set warning level so we don't see chatter about nonexistent DB */ psql_add_command(buf, "SET client_min_messages = warning"); psql_add_command(buf, "DROP DATABASE IF EXISTS \"%s\"", dbname); psql_end_command(buf, "postgres"); } static void create_database(const char *dbname) { StringInfo buf = psql_start_command(); _stringlist *sl; /* * We use template0 so that any installation-local cruft in template1 will * not mess up the tests. */ if (encoding) psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding, (nolocale) ? " LOCALE='C'" : ""); else psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname, (nolocale) ? " LOCALE='C'" : ""); psql_add_command(buf, "ALTER DATABASE \"%s\" SET lc_messages TO 'C';" "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';" "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';" "ALTER DATABASE \"%s\" SET lc_time TO 'C';" "ALTER DATABASE \"%s\" SET bytea_output TO 'hex';" "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';", dbname, dbname, dbname, dbname, dbname, dbname); psql_end_command(buf, "postgres"); /* * Install any requested extensions. We use CREATE IF NOT EXISTS so that * this will work whether or not the extension is preinstalled. */ for (sl = loadextension; sl != NULL; sl = sl->next) psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str); } static void drop_role_if_exists(const char *rolename) { StringInfo buf = psql_start_command(); /* Set warning level so we don't see chatter about nonexistent role */ psql_add_command(buf, "SET client_min_messages = warning"); psql_add_command(buf, "DROP ROLE IF EXISTS \"%s\"", rolename); psql_end_command(buf, "postgres"); } static void create_role(const char *rolename, const _stringlist *granted_dbs) { StringInfo buf = psql_start_command(); psql_add_command(buf, "CREATE ROLE \"%s\" WITH LOGIN", rolename); for (; granted_dbs != NULL; granted_dbs = granted_dbs->next) { psql_add_command(buf, "GRANT ALL ON DATABASE \"%s\" TO \"%s\"", granted_dbs->str, rolename); } psql_end_command(buf, "postgres"); } static void help(void) { printf(_("PostgreSQL regression test driver\n")); printf(_("\n")); printf(_("Usage:\n %s [OPTION]... [EXTRA-TEST]...\n"), progname); printf(_("\n")); printf(_("Options:\n")); printf(_(" --bindir=BINPATH use BINPATH for programs that are run;\n")); printf(_(" if empty, use PATH from the environment\n")); printf(_(" --config-auth=DATADIR update authentication settings for DATADIR\n")); printf(_(" --create-role=ROLE create the specified role before testing\n")); printf(_(" --dbname=DB use database DB (default \"regression\")\n")); printf(_(" --debug turn on debug mode in programs that are run\n")); printf(_(" --dlpath=DIR look for dynamic libraries in DIR\n")); printf(_(" --encoding=ENCODING use ENCODING as the encoding\n")); printf(_(" --expecteddir=DIR take expected files from DIR (default \".\")\n")); printf(_(" -h, --help show this help, then exit\n")); printf(_(" --inputdir=DIR take input files from DIR (default \".\")\n")); printf(_(" --launcher=CMD use CMD as launcher of psql\n")); printf(_(" --load-extension=EXT load the named extension before running the\n")); printf(_(" tests; can appear multiple times\n")); printf(_(" --max-connections=N maximum number of concurrent connections\n")); printf(_(" (default is 0, meaning unlimited)\n")); printf(_(" --max-concurrent-tests=N maximum number of concurrent tests in schedule\n")); printf(_(" (default is 0, meaning unlimited)\n")); printf(_(" --outputdir=DIR place output files in DIR (default \".\")\n")); printf(_(" --schedule=FILE use test ordering schedule from FILE\n")); printf(_(" (can be used multiple times to concatenate)\n")); printf(_(" --temp-instance=DIR create a temporary instance in DIR\n")); printf(_(" --use-existing use an existing installation\n")); printf(_(" -V, --version output version information, then exit\n")); printf(_("\n")); printf(_("Options for \"temp-instance\" mode:\n")); printf(_(" --no-locale use C locale\n")); printf(_(" --port=PORT start postmaster on PORT\n")); printf(_(" --temp-config=FILE append contents of FILE to temporary config\n")); printf(_("\n")); printf(_("Options for using an existing installation:\n")); printf(_(" --host=HOST use postmaster running on HOST\n")); printf(_(" --port=PORT use postmaster running at PORT\n")); printf(_(" --user=USER connect as USER\n")); printf(_("\n")); printf(_("The exit status is 0 if all tests passed, 1 if some tests failed, and 2\n")); printf(_("if the tests could not be run for some reason.\n")); printf(_("\n")); printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT); printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL); } int regression_main(int argc, char *argv[], init_function ifunc, test_start_function startfunc, postprocess_result_function postfunc) { static struct option long_options[] = { {"help", no_argument, NULL, 'h'}, {"version", no_argument, NULL, 'V'}, {"dbname", required_argument, NULL, 1}, {"debug", no_argument, NULL, 2}, {"inputdir", required_argument, NULL, 3}, {"max-connections", required_argument, NULL, 5}, {"encoding", required_argument, NULL, 6}, {"outputdir", required_argument, NULL, 7}, {"schedule", required_argument, NULL, 8}, {"temp-instance", required_argument, NULL, 9}, {"no-locale", no_argument, NULL, 10}, {"host", required_argument, NULL, 13}, {"port", required_argument, NULL, 14}, {"user", required_argument, NULL, 15}, {"bindir", required_argument, NULL, 16}, {"dlpath", required_argument, NULL, 17}, {"create-role", required_argument, NULL, 18}, {"temp-config", required_argument, NULL, 19}, {"use-existing", no_argument, NULL, 20}, {"launcher", required_argument, NULL, 21}, {"load-extension", required_argument, NULL, 22}, {"config-auth", required_argument, NULL, 24}, {"max-concurrent-tests", required_argument, NULL, 25}, {"expecteddir", required_argument, NULL, 26}, {NULL, 0, NULL, 0} }; bool use_unix_sockets; _stringlist *sl; int c; int i; int option_index; char buf[MAXPGPATH * 4]; pg_logging_init(argv[0]); progname = get_progname(argv[0]); set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress")); get_restricted_token(); atexit(stop_postmaster); #if defined(WIN32) /* * We don't use Unix-domain sockets on Windows by default (see comment at * remove_temp() for a reason). Override at your own risk. */ use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false; #else use_unix_sockets = true; #endif if (!use_unix_sockets) hostname = "localhost"; /* * We call the initialization function here because that way we can set * default parameters and let them be overwritten by the commandline. */ ifunc(argc, argv); if (getenv("PG_REGRESS_DIFF_OPTS")) pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS"); while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1) { switch (c) { case 'h': help(); exit(0); case 'V': puts("pg_regress (PostgreSQL) " PG_VERSION); exit(0); case 1: /* * If a default database was specified, we need to remove it * before we add the specified one. */ free_stringlist(&dblist); split_to_stringlist(optarg, ",", &dblist); break; case 2: debug = true; break; case 3: inputdir = pg_strdup(optarg); break; case 5: max_connections = atoi(optarg); break; case 6: encoding = pg_strdup(optarg); break; case 7: outputdir = pg_strdup(optarg); break; case 8: add_stringlist_item(&schedulelist, optarg); break; case 9: temp_instance = make_absolute_path(optarg); break; case 10: nolocale = true; break; case 13: hostname = pg_strdup(optarg); break; case 14: port = atoi(optarg); port_specified_by_user = true; break; case 15: user = pg_strdup(optarg); break; case 16: /* "--bindir=" means to use PATH */ if (strlen(optarg)) bindir = pg_strdup(optarg); else bindir = NULL; break; case 17: dlpath = pg_strdup(optarg); break; case 18: split_to_stringlist(optarg, ",", &extraroles); break; case 19: add_stringlist_item(&temp_configs, optarg); break; case 20: use_existing = true; break; case 21: launcher = pg_strdup(optarg); break; case 22: add_stringlist_item(&loadextension, optarg); break; case 24: config_auth_datadir = pg_strdup(optarg); break; case 25: max_concurrent_tests = atoi(optarg); break; case 26: expecteddir = pg_strdup(optarg); break; default: /* getopt_long already emitted a complaint */ pg_log_error_hint("Try \"%s --help\" for more information.", progname); exit(2); } } /* * if we still have arguments, they are extra tests to run */ while (argc - optind >= 1) { add_stringlist_item(&extra_tests, argv[optind]); optind++; } /* * We must have a database to run the tests in; either a default name, or * one supplied by the --dbname switch. */ if (!(dblist && dblist->str && dblist->str[0])) { bail("no database name was specified"); } if (config_auth_datadir) { #ifdef ENABLE_SSPI if (!use_unix_sockets) config_sspi_auth(config_auth_datadir, user); #endif exit(0); } if (temp_instance && !port_specified_by_user) /* * To reduce chances of interference with parallel installations, use * a port number starting in the private range (49152-65535) * calculated from the version number. This aids non-Unix socket mode * systems; elsewhere, the use of a private socket directory already * prevents interference. */ port = 0xC000 | (PG_VERSION_NUM & 0x3FFF); inputdir = make_absolute_path(inputdir); outputdir = make_absolute_path(outputdir); expecteddir = make_absolute_path(expecteddir); dlpath = make_absolute_path(dlpath); /* * Initialization */ open_result_files(); initialize_environment(); #if defined(HAVE_GETRLIMIT) unlimit_core_size(); #endif if (temp_instance) { StringInfoData cmd; FILE *pg_conf; const char *env_wait; int wait_seconds; const char *initdb_template_dir; const char *keywords[4]; const char *values[4]; PGPing rv; const char *initdb_extra_opts_env; /* * Prepare the temp instance */ if (directory_exists(temp_instance)) { if (!rmtree(temp_instance, true)) { bail("could not remove temp instance \"%s\"", temp_instance); } } /* make the temp instance top directory */ make_directory(temp_instance); /* and a directory for log files */ snprintf(buf, sizeof(buf), "%s/log", outputdir); if (!directory_exists(buf)) make_directory(buf); initdb_extra_opts_env = getenv("PG_TEST_INITDB_EXTRA_OPTS"); initStringInfo(&cmd); /* * Create data directory. * * If available, use a previously initdb'd cluster as a template by * copying it. For a lot of tests, that's substantially cheaper. * * There's very similar code in Cluster.pm, but we can't easily de * duplicate it until we require perl at build time. */ initdb_template_dir = getenv("INITDB_TEMPLATE"); if (initdb_template_dir == NULL || nolocale || debug || initdb_extra_opts_env) { note("initializing database system by running initdb"); appendStringInfo(&cmd, "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync", bindir ? bindir : "", bindir ? "/" : "", temp_instance); if (debug) appendStringInfoString(&cmd, " --debug"); if (nolocale) appendStringInfoString(&cmd, " --no-locale"); if (initdb_extra_opts_env) appendStringInfo(&cmd, " %s", initdb_extra_opts_env); appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir); fflush(NULL); if (system(cmd.data)) { bail("initdb failed\n" "# Examine \"%s/log/initdb.log\" for the reason.\n" "# Command was: %s", outputdir, cmd.data); } } else { #ifndef WIN32 const char *copycmd = "cp -RPp \"%s\" \"%s/data\""; int expected_exitcode = 0; #else const char *copycmd = "robocopy /E /NJS /NJH /NFL /NDL /NP \"%s\" \"%s/data\""; int expected_exitcode = 1; /* 1 denotes files were copied */ #endif note("initializing database system by copying initdb template"); appendStringInfo(&cmd, copycmd, initdb_template_dir, temp_instance); appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir); fflush(NULL); if (system(cmd.data) != expected_exitcode) { bail("copying of initdb template failed\n" "# Examine \"%s/log/initdb.log\" for the reason.\n" "# Command was: %s", outputdir, cmd.data); } } pfree(cmd.data); /* * Adjust the default postgresql.conf for regression testing. The user * can specify a file to be appended; in any case we expand logging * and set max_prepared_transactions to enable testing of prepared * xacts. (Note: to reduce the probability of unexpected shmmax * failures, don't set max_prepared_transactions any higher than * actually needed by the prepared_xacts regression test.) */ snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance); pg_conf = fopen(buf, "a"); if (pg_conf == NULL) bail("could not open \"%s\" for adding extra config: %m", buf); fputs("\n# Configuration added by pg_regress\n\n", pg_conf); fputs("log_autovacuum_min_duration = 0\n", pg_conf); fputs("log_checkpoints = on\n", pg_conf); fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf); fputs("log_lock_waits = on\n", pg_conf); fputs("log_temp_files = 128kB\n", pg_conf); fputs("max_prepared_transactions = 2\n", pg_conf); for (sl = temp_configs; sl != NULL; sl = sl->next) { char *temp_config = sl->str; FILE *extra_conf; char line_buf[1024]; extra_conf = fopen(temp_config, "r"); if (extra_conf == NULL) { bail("could not open \"%s\" to read extra config: %m", temp_config); } while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL) fputs(line_buf, pg_conf); fclose(extra_conf); } fclose(pg_conf); #ifdef ENABLE_SSPI if (!use_unix_sockets) { /* * Since we successfully used the same buffer for the much-longer * "initdb" command, this can't truncate. */ snprintf(buf, sizeof(buf), "%s/data", temp_instance); config_sspi_auth(buf, NULL); } #endif /* * Prepare the connection params for checking the state of the server * before starting the tests. */ sprintf(portstr, "%d", port); keywords[0] = "dbname"; values[0] = "postgres"; keywords[1] = "port"; values[1] = portstr; keywords[2] = "host"; values[2] = hostname ? hostname : sockdir; keywords[3] = NULL; values[3] = NULL; /* * Check if there is a postmaster running already. */ for (i = 0; i < 16; i++) { rv = PQpingParams(keywords, values, 1); if (rv == PQPING_OK) { if (port_specified_by_user || i == 15) { note("port %d apparently in use", port); if (!port_specified_by_user) note("could not determine an available port"); bail("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers."); } note("port %d apparently in use, trying %d", port, port + 1); port++; sprintf(portstr, "%d", port); setenv("PGPORT", portstr, 1); } else break; } /* * Start the temp postmaster */ snprintf(buf, sizeof(buf), "\"%s%spostgres\" -D \"%s/data\" -F%s " "-c \"listen_addresses=%s\" -k \"%s\" " "> \"%s/log/postmaster.log\" 2>&1", bindir ? bindir : "", bindir ? "/" : "", temp_instance, debug ? " -d 5" : "", hostname ? hostname : "", sockdir ? sockdir : "", outputdir); postmaster_pid = spawn_process(buf); if (postmaster_pid == INVALID_PID) bail("could not spawn postmaster: %m"); /* * Wait till postmaster is able to accept connections; normally takes * only a fraction of a second or so, but Cygwin is reportedly *much* * slower, and test builds using Valgrind or similar tools might be * too. Hence, allow the default timeout of 60 seconds to be * overridden from the PGCTLTIMEOUT environment variable. */ env_wait = getenv("PGCTLTIMEOUT"); if (env_wait != NULL) { wait_seconds = atoi(env_wait); if (wait_seconds <= 0) wait_seconds = 60; } else wait_seconds = 60; for (i = 0; i < wait_seconds * WAIT_TICKS_PER_SECOND; i++) { /* * It's fairly unlikely that the server is responding immediately * so we start with sleeping before checking instead of the other * way around. */ pg_usleep(1000000L / WAIT_TICKS_PER_SECOND); rv = PQpingParams(keywords, values, 1); /* Done if the server is running and accepts connections */ if (rv == PQPING_OK) break; if (rv == PQPING_NO_ATTEMPT) bail("attempting to connect to postmaster failed"); /* * Fail immediately if postmaster has exited */ #ifndef WIN32 if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid) #else if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0) #endif { bail("postmaster failed, examine \"%s/log/postmaster.log\" for the reason", outputdir); } } if (i >= wait_seconds * WAIT_TICKS_PER_SECOND) { diag("postmaster did not respond within %d seconds, examine \"%s/log/postmaster.log\" for the reason", wait_seconds, outputdir); /* * If we get here, the postmaster is probably wedged somewhere in * startup. Try to kill it ungracefully rather than leaving a * stuck postmaster that might interfere with subsequent test * attempts. */ #ifndef WIN32 if (kill(postmaster_pid, SIGKILL) != 0 && errno != ESRCH) bail("could not kill failed postmaster: %m"); #else if (TerminateProcess(postmaster_pid, 255) == 0) bail("could not kill failed postmaster: error code %lu", GetLastError()); #endif bail("postmaster failed"); } postmaster_running = true; #ifdef _WIN64 /* need a series of two casts to convert HANDLE without compiler warning */ #define ULONGPID(x) (unsigned long) (unsigned long long) (x) #else #define ULONGPID(x) (unsigned long) (x) #endif note("using temp instance on port %d with PID %lu", port, ULONGPID(postmaster_pid)); } else { /* * Using an existing installation, so may need to get rid of * pre-existing database(s) and role(s) */ if (!use_existing) { for (sl = dblist; sl; sl = sl->next) drop_database_if_exists(sl->str); for (sl = extraroles; sl; sl = sl->next) drop_role_if_exists(sl->str); } } /* * Create the test database(s) and role(s) */ if (!use_existing) { for (sl = dblist; sl; sl = sl->next) create_database(sl->str); for (sl = extraroles; sl; sl = sl->next) create_role(sl->str, dblist); } /* * Ready to run the tests */ for (sl = schedulelist; sl != NULL; sl = sl->next) { run_schedule(sl->str, startfunc, postfunc); } for (sl = extra_tests; sl != NULL; sl = sl->next) { run_single_test(sl->str, startfunc, postfunc); } /* * Shut down temp installation's postmaster */ if (temp_instance) { stop_postmaster(); } /* * If there were no errors, remove the temp instance immediately to * conserve disk space. (If there were errors, we leave the instance in * place for possible manual investigation.) */ if (temp_instance && fail_count == 0) { if (!rmtree(temp_instance, true)) diag("could not remove temp instance \"%s\"", temp_instance); } /* * Emit a TAP compliant Plan */ plan(fail_count + success_count); /* * Emit nice-looking summary message */ if (fail_count == 0) note("All %d tests passed.", success_count); else diag("%d of %d tests failed.", fail_count, success_count + fail_count); if (file_size(difffilename) > 0) { diag("The differences that caused some tests to fail can be viewed in the file \"%s\".", difffilename); diag("A copy of the test summary that you see above is saved in the file \"%s\".", logfilename); } else { unlink(difffilename); unlink(logfilename); } fclose(logfile); logfile = NULL; if (fail_count != 0) exit(1); return 0; }