PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
pg_regress.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pg_regress --- regression test driver
4  *
5  * This is a C implementation of the previous shell script for running
6  * the regression tests, and should be mostly compatible with it.
7  * Initial author of C translation: Magnus Hagander
8  *
9  * This code is released under the terms of the PostgreSQL License.
10  *
11  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
12  * Portions Copyright (c) 1994, Regents of the University of California
13  *
14  * src/test/regress/pg_regress.c
15  *
16  *-------------------------------------------------------------------------
17  */
18 
19 #include "pg_regress.h"
20 
21 #include <ctype.h>
22 #include <sys/stat.h>
23 #include <sys/wait.h>
24 #include <signal.h>
25 #include <unistd.h>
26 
27 #ifdef HAVE_SYS_RESOURCE_H
28 #include <sys/time.h>
29 #include <sys/resource.h>
30 #endif
31 
33 #include "common/username.h"
34 #include "getopt_long.h"
35 #include "libpq/pqcomm.h" /* needed for UNIXSOCK_PATH() */
36 #include "pg_config_paths.h"
37 
38 /* for resultmap we need a list of pairs of strings */
39 typedef struct _resultmap
40 {
41  char *test;
42  char *type;
43  char *resultfile;
44  struct _resultmap *next;
45 } _resultmap;
46 
47 /*
48  * Values obtained from Makefile.
49  */
50 char *host_platform = HOST_TUPLE;
51 
52 #ifndef WIN32 /* not used in WIN32 case */
53 static char *shellprog = SHELLPROG;
54 #endif
55 
56 /*
57  * On Windows we use -w in diff switches to avoid problems with inconsistent
58  * newline representation. The actual result files will generally have
59  * Windows-style newlines, but the comparison files might or might not.
60  */
61 #ifndef WIN32
62 const char *basic_diff_opts = "";
63 const char *pretty_diff_opts = "-C3";
64 #else
65 const char *basic_diff_opts = "-w";
66 const char *pretty_diff_opts = "-w -C3";
67 #endif
68 
69 /* options settable from command line */
71 bool debug = false;
72 char *inputdir = ".";
73 char *outputdir = ".";
74 char *bindir = PGBINDIR;
75 char *launcher = NULL;
78 static int max_connections = 0;
79 static char *encoding = NULL;
82 static char *temp_instance = NULL;
84 static bool nolocale = false;
85 static bool use_existing = false;
86 static char *hostname = NULL;
87 static int port = -1;
88 static bool port_specified_by_user = false;
89 static char *dlpath = PKGLIBDIR;
90 static char *user = NULL;
92 static char *config_auth_datadir = NULL;
93 
94 /* internal variables */
95 static const char *progname;
96 static char *logfilename;
97 static FILE *logfile;
98 static char *difffilename;
99 static const char *sockdir;
100 #ifdef HAVE_UNIX_SOCKETS
101 static const char *temp_sockdir;
102 static char sockself[MAXPGPATH];
103 static char socklock[MAXPGPATH];
104 #endif
105 
107 
109 static bool postmaster_running = false;
110 
111 static int success_count = 0;
112 static int fail_count = 0;
113 static int fail_ignore_count = 0;
114 
115 static bool directory_exists(const char *dir);
116 static void make_directory(const char *dir);
117 
118 static void header(const char *fmt,...) pg_attribute_printf(1, 2);
119 static void status(const char *fmt,...) pg_attribute_printf(1, 2);
120 static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2, 3);
121 
122 /*
123  * allow core files if possible.
124  */
125 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
126 static void
127 unlimit_core_size(void)
128 {
129  struct rlimit lim;
130 
131  getrlimit(RLIMIT_CORE, &lim);
132  if (lim.rlim_max == 0)
133  {
134  fprintf(stderr,
135  _("%s: could not set core size: disallowed by hard limit\n"),
136  progname);
137  return;
138  }
139  else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
140  {
141  lim.rlim_cur = lim.rlim_max;
142  setrlimit(RLIMIT_CORE, &lim);
143  }
144 }
145 #endif
146 
147 
148 /*
149  * Add an item at the end of a stringlist.
150  */
151 void
152 add_stringlist_item(_stringlist **listhead, const char *str)
153 {
154  _stringlist *newentry = pg_malloc(sizeof(_stringlist));
155  _stringlist *oldentry;
156 
157  newentry->str = pg_strdup(str);
158  newentry->next = NULL;
159  if (*listhead == NULL)
160  *listhead = newentry;
161  else
162  {
163  for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
164  /* skip */ ;
165  oldentry->next = newentry;
166  }
167 }
168 
169 /*
170  * Free a stringlist.
171  */
172 static void
174 {
175  if (listhead == NULL || *listhead == NULL)
176  return;
177  if ((*listhead)->next != NULL)
178  free_stringlist(&((*listhead)->next));
179  free((*listhead)->str);
180  free(*listhead);
181  *listhead = NULL;
182 }
183 
184 /*
185  * Split a delimited string into a stringlist
186  */
187 static void
188 split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
189 {
190  char *sc = pg_strdup(s);
191  char *token = strtok(sc, delim);
192 
193  while (token)
194  {
195  add_stringlist_item(listhead, token);
196  token = strtok(NULL, delim);
197  }
198  free(sc);
199 }
200 
201 /*
202  * Print a progress banner on stdout.
203  */
204 static void
205 header(const char *fmt,...)
206 {
207  char tmp[64];
208  va_list ap;
209 
210  va_start(ap, fmt);
211  vsnprintf(tmp, sizeof(tmp), fmt, ap);
212  va_end(ap);
213 
214  fprintf(stdout, "============== %-38s ==============\n", tmp);
215  fflush(stdout);
216 }
217 
218 /*
219  * Print "doing something ..." --- supplied text should not end with newline
220  */
221 static void
222 status(const char *fmt,...)
223 {
224  va_list ap;
225 
226  va_start(ap, fmt);
227  vfprintf(stdout, fmt, ap);
228  fflush(stdout);
229  va_end(ap);
230 
231  if (logfile)
232  {
233  va_start(ap, fmt);
234  vfprintf(logfile, fmt, ap);
235  va_end(ap);
236  }
237 }
238 
239 /*
240  * Done "doing something ..."
241  */
242 static void
244 {
245  fprintf(stdout, "\n");
246  fflush(stdout);
247  if (logfile)
248  fprintf(logfile, "\n");
249 }
250 
251 /*
252  * shut down temp postmaster
253  */
254 static void
256 {
257  if (postmaster_running)
258  {
259  /* We use pg_ctl to issue the kill and wait for stop */
260  char buf[MAXPGPATH * 2];
261  int r;
262 
263  /* On Windows, system() seems not to force fflush, so... */
264  fflush(stdout);
265  fflush(stderr);
266 
267  snprintf(buf, sizeof(buf),
268  "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
269  bindir ? bindir : "",
270  bindir ? "/" : "",
271  temp_instance);
272  r = system(buf);
273  if (r != 0)
274  {
275  fprintf(stderr, _("\n%s: could not stop postmaster: exit code was %d\n"),
276  progname, r);
277  _exit(2); /* not exit(), that could be recursive */
278  }
279 
280  postmaster_running = false;
281  }
282 }
283 
284 #ifdef HAVE_UNIX_SOCKETS
285 /*
286  * Remove the socket temporary directory. pg_regress never waits for a
287  * postmaster exit, so it is indeterminate whether the postmaster has yet to
288  * unlink the socket and lock file. Unlink them here so we can proceed to
289  * remove the directory. Ignore errors; leaking a temporary directory is
290  * unimportant. This can run from a signal handler. The code is not
291  * acceptable in a Windows signal handler (see initdb.c:trapsig()), but
292  * Windows is not a HAVE_UNIX_SOCKETS platform.
293  */
294 static void
295 remove_temp(void)
296 {
297  Assert(temp_sockdir);
298  unlink(sockself);
299  unlink(socklock);
300  rmdir(temp_sockdir);
301 }
302 
303 /*
304  * Signal handler that calls remove_temp() and reraises the signal.
305  */
306 static void
307 signal_remove_temp(int signum)
308 {
309  remove_temp();
310 
311  pqsignal(signum, SIG_DFL);
312  raise(signum);
313 }
314 
315 /*
316  * Create a temporary directory suitable for the server's Unix-domain socket.
317  * The directory will have mode 0700 or stricter, so no other OS user can open
318  * our socket to exploit our use of trust authentication. Most systems
319  * constrain the length of socket paths well below _POSIX_PATH_MAX, so we
320  * place the directory under /tmp rather than relative to the possibly-deep
321  * current working directory.
322  *
323  * Compared to using the compiled-in DEFAULT_PGSOCKET_DIR, this also permits
324  * testing to work in builds that relocate it to a directory not writable to
325  * the build/test user.
326  */
327 static const char *
328 make_temp_sockdir(void)
329 {
330  char *template = pg_strdup("/tmp/pg_regress-XXXXXX");
331 
332  temp_sockdir = mkdtemp(template);
333  if (temp_sockdir == NULL)
334  {
335  fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
336  progname, template, strerror(errno));
337  exit(2);
338  }
339 
340  /* Stage file names for remove_temp(). Unsafe in a signal handler. */
341  UNIXSOCK_PATH(sockself, port, temp_sockdir);
342  snprintf(socklock, sizeof(socklock), "%s.lock", sockself);
343 
344  /* Remove the directory during clean exit. */
345  atexit(remove_temp);
346 
347  /*
348  * Remove the directory before dying to the usual signals. Omit SIGQUIT,
349  * preserving it as a quick, untidy exit.
350  */
351  pqsignal(SIGHUP, signal_remove_temp);
352  pqsignal(SIGINT, signal_remove_temp);
353  pqsignal(SIGPIPE, signal_remove_temp);
354  pqsignal(SIGTERM, signal_remove_temp);
355 
356  return temp_sockdir;
357 }
358 #endif /* HAVE_UNIX_SOCKETS */
359 
360 /*
361  * Check whether string matches pattern
362  *
363  * In the original shell script, this function was implemented using expr(1),
364  * which provides basic regular expressions restricted to match starting at
365  * the string start (in conventional regex terms, there's an implicit "^"
366  * at the start of the pattern --- but no implicit "$" at the end).
367  *
368  * For now, we only support "." and ".*" as non-literal metacharacters,
369  * because that's all that anyone has found use for in resultmap. This
370  * code could be extended if more functionality is needed.
371  */
372 static bool
373 string_matches_pattern(const char *str, const char *pattern)
374 {
375  while (*str && *pattern)
376  {
377  if (*pattern == '.' && pattern[1] == '*')
378  {
379  pattern += 2;
380  /* Trailing .* matches everything. */
381  if (*pattern == '\0')
382  return true;
383 
384  /*
385  * Otherwise, scan for a text position at which we can match the
386  * rest of the pattern.
387  */
388  while (*str)
389  {
390  /*
391  * Optimization to prevent most recursion: don't recurse
392  * unless first pattern char might match this text char.
393  */
394  if (*str == *pattern || *pattern == '.')
395  {
396  if (string_matches_pattern(str, pattern))
397  return true;
398  }
399 
400  str++;
401  }
402 
403  /*
404  * End of text with no match.
405  */
406  return false;
407  }
408  else if (*pattern != '.' && *str != *pattern)
409  {
410  /*
411  * Not the single-character wildcard and no explicit match? Then
412  * time to quit...
413  */
414  return false;
415  }
416 
417  str++;
418  pattern++;
419  }
420 
421  if (*pattern == '\0')
422  return true; /* end of pattern, so declare match */
423 
424  /* End of input string. Do we have matching pattern remaining? */
425  while (*pattern == '.' && pattern[1] == '*')
426  pattern += 2;
427  if (*pattern == '\0')
428  return true; /* end of pattern, so declare match */
429 
430  return false;
431 }
432 
433 /*
434  * Replace all occurrences of a string in a string with a different string.
435  * NOTE: Assumes there is enough room in the target buffer!
436  */
437 void
438 replace_string(char *string, char *replace, char *replacement)
439 {
440  char *ptr;
441 
442  while ((ptr = strstr(string, replace)) != NULL)
443  {
444  char *dup = pg_strdup(string);
445 
446  strlcpy(string, dup, ptr - string + 1);
447  strcat(string, replacement);
448  strcat(string, dup + (ptr - string) + strlen(replace));
449  free(dup);
450  }
451 }
452 
453 /*
454  * Convert *.source found in the "source" directory, replacing certain tokens
455  * in the file contents with their intended values, and put the resulting files
456  * in the "dest" directory, replacing the ".source" prefix in their names with
457  * the given suffix.
458  */
459 static void
460 convert_sourcefiles_in(char *source_subdir, char *dest_dir, char *dest_subdir, char *suffix)
461 {
462  char testtablespace[MAXPGPATH];
463  char indir[MAXPGPATH];
464  struct stat st;
465  int ret;
466  char **name;
467  char **names;
468  int count = 0;
469 
470  snprintf(indir, MAXPGPATH, "%s/%s", inputdir, source_subdir);
471 
472  /* Check that indir actually exists and is a directory */
473  ret = stat(indir, &st);
474  if (ret != 0 || !S_ISDIR(st.st_mode))
475  {
476  /*
477  * No warning, to avoid noise in tests that do not have these
478  * directories; for example, ecpg, contrib and src/pl.
479  */
480  return;
481  }
482 
483  names = pgfnames(indir);
484  if (!names)
485  /* Error logged in pgfnames */
486  exit(2);
487 
488  snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);
489 
490 #ifdef WIN32
491 
492  /*
493  * On Windows only, clean out the test tablespace dir, or create it if it
494  * doesn't exist. On other platforms we expect the Makefile to take care
495  * of that. (We don't migrate that functionality in here because it'd be
496  * harder to cope with platform-specific issues such as SELinux.)
497  *
498  * XXX it would be better if pg_regress.c had nothing at all to do with
499  * testtablespace, and this were handled by a .BAT file or similar on
500  * Windows. See pgsql-hackers discussion of 2008-01-18.
501  */
502  if (directory_exists(testtablespace))
503  if (!rmtree(testtablespace, true))
504  {
505  fprintf(stderr, _("\n%s: could not remove test tablespace \"%s\"\n"),
506  progname, testtablespace);
507  exit(2);
508  }
509  make_directory(testtablespace);
510 #endif
511 
512  /* finally loop on each file and do the replacement */
513  for (name = names; *name; name++)
514  {
515  char srcfile[MAXPGPATH];
516  char destfile[MAXPGPATH];
517  char prefix[MAXPGPATH];
518  FILE *infile,
519  *outfile;
520  char line[1024];
521 
522  /* reject filenames not finishing in ".source" */
523  if (strlen(*name) < 8)
524  continue;
525  if (strcmp(*name + strlen(*name) - 7, ".source") != 0)
526  continue;
527 
528  count++;
529 
530  /* build the full actual paths to open */
531  snprintf(prefix, strlen(*name) - 6, "%s", *name);
532  snprintf(srcfile, MAXPGPATH, "%s/%s", indir, *name);
533  snprintf(destfile, MAXPGPATH, "%s/%s/%s.%s", dest_dir, dest_subdir,
534  prefix, suffix);
535 
536  infile = fopen(srcfile, "r");
537  if (!infile)
538  {
539  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
540  progname, srcfile, strerror(errno));
541  exit(2);
542  }
543  outfile = fopen(destfile, "w");
544  if (!outfile)
545  {
546  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
547  progname, destfile, strerror(errno));
548  exit(2);
549  }
550  while (fgets(line, sizeof(line), infile))
551  {
552  replace_string(line, "@abs_srcdir@", inputdir);
553  replace_string(line, "@abs_builddir@", outputdir);
554  replace_string(line, "@testtablespace@", testtablespace);
555  replace_string(line, "@libdir@", dlpath);
556  replace_string(line, "@DLSUFFIX@", DLSUFFIX);
557  fputs(line, outfile);
558  }
559  fclose(infile);
560  fclose(outfile);
561  }
562 
563  /*
564  * If we didn't process any files, complain because it probably means
565  * somebody neglected to pass the needed --inputdir argument.
566  */
567  if (count <= 0)
568  {
569  fprintf(stderr, _("%s: no *.source files found in \"%s\"\n"),
570  progname, indir);
571  exit(2);
572  }
573 
574  pgfnames_cleanup(names);
575 }
576 
577 /* Create the .sql and .out files from the .source files, if any */
578 static void
580 {
581  convert_sourcefiles_in("input", outputdir, "sql", "sql");
582  convert_sourcefiles_in("output", outputdir, "expected", "out");
583 }
584 
585 /*
586  * Scan resultmap file to find which platform-specific expected files to use.
587  *
588  * The format of each line of the file is
589  * testname/hostplatformpattern=substitutefile
590  * where the hostplatformpattern is evaluated per the rules of expr(1),
591  * namely, it is a standard regular expression with an implicit ^ at the start.
592  * (We currently support only a very limited subset of regular expressions,
593  * see string_matches_pattern() above.) What hostplatformpattern will be
594  * matched against is the config.guess output. (In the shell-script version,
595  * we also provided an indication of whether gcc or another compiler was in
596  * use, but that facility isn't used anymore.)
597  */
598 static void
600 {
601  char buf[MAXPGPATH];
602  FILE *f;
603 
604  /* scan the file ... */
605  snprintf(buf, sizeof(buf), "%s/resultmap", inputdir);
606  f = fopen(buf, "r");
607  if (!f)
608  {
609  /* OK if it doesn't exist, else complain */
610  if (errno == ENOENT)
611  return;
612  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
613  progname, buf, strerror(errno));
614  exit(2);
615  }
616 
617  while (fgets(buf, sizeof(buf), f))
618  {
619  char *platform;
620  char *file_type;
621  char *expected;
622  int i;
623 
624  /* strip trailing whitespace, especially the newline */
625  i = strlen(buf);
626  while (i > 0 && isspace((unsigned char) buf[i - 1]))
627  buf[--i] = '\0';
628 
629  /* parse out the line fields */
630  file_type = strchr(buf, ':');
631  if (!file_type)
632  {
633  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
634  buf);
635  exit(2);
636  }
637  *file_type++ = '\0';
638 
639  platform = strchr(file_type, ':');
640  if (!platform)
641  {
642  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
643  buf);
644  exit(2);
645  }
646  *platform++ = '\0';
647  expected = strchr(platform, '=');
648  if (!expected)
649  {
650  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
651  buf);
652  exit(2);
653  }
654  *expected++ = '\0';
655 
656  /*
657  * if it's for current platform, save it in resultmap list. Note: by
658  * adding at the front of the list, we ensure that in ambiguous cases,
659  * the last match in the resultmap file is used. This mimics the
660  * behavior of the old shell script.
661  */
662  if (string_matches_pattern(host_platform, platform))
663  {
664  _resultmap *entry = pg_malloc(sizeof(_resultmap));
665 
666  entry->test = pg_strdup(buf);
667  entry->type = pg_strdup(file_type);
668  entry->resultfile = pg_strdup(expected);
669  entry->next = resultmap;
670  resultmap = entry;
671  }
672  }
673  fclose(f);
674 }
675 
676 /*
677  * Check in resultmap if we should be looking at a different file
678  */
679 static
680 const char *
681 get_expectfile(const char *testname, const char *file)
682 {
683  char *file_type;
684  _resultmap *rm;
685 
686  /*
687  * Determine the file type from the file name. This is just what is
688  * following the last dot in the file name.
689  */
690  if (!file || !(file_type = strrchr(file, '.')))
691  return NULL;
692 
693  file_type++;
694 
695  for (rm = resultmap; rm != NULL; rm = rm->next)
696  {
697  if (strcmp(testname, rm->test) == 0 && strcmp(file_type, rm->type) == 0)
698  {
699  return rm->resultfile;
700  }
701  }
702 
703  return NULL;
704 }
705 
706 /*
707  * Handy subroutine for setting an environment variable "var" to "val"
708  */
709 static void
710 doputenv(const char *var, const char *val)
711 {
712  char *s;
713 
714  s = psprintf("%s=%s", var, val);
715  putenv(s);
716 }
717 
718 /*
719  * Prepare environment variables for running regression tests
720  */
721 static void
723 {
724  putenv("PGAPPNAME=pg_regress");
725 
726  if (nolocale)
727  {
728  /*
729  * Clear out any non-C locale settings
730  */
731  unsetenv("LC_COLLATE");
732  unsetenv("LC_CTYPE");
733  unsetenv("LC_MONETARY");
734  unsetenv("LC_NUMERIC");
735  unsetenv("LC_TIME");
736  unsetenv("LANG");
737 
738  /*
739  * Most platforms have adopted the POSIX locale as their
740  * implementation-defined default locale. Exceptions include native
741  * Windows, macOS with --enable-nls, and Cygwin with --enable-nls.
742  * (Use of --enable-nls matters because libintl replaces setlocale().)
743  * Also, PostgreSQL does not support macOS with locale environment
744  * variables unset; see PostmasterMain().
745  */
746 #if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__)
747  putenv("LANG=C");
748 #endif
749  }
750 
751  /*
752  * Set translation-related settings to English; otherwise psql will
753  * produce translated messages and produce diffs. (XXX If we ever support
754  * translation of pg_regress, this needs to be moved elsewhere, where psql
755  * is actually called.)
756  */
757  unsetenv("LANGUAGE");
758  unsetenv("LC_ALL");
759  putenv("LC_MESSAGES=C");
760 
761  /*
762  * Set encoding as requested
763  */
764  if (encoding)
765  doputenv("PGCLIENTENCODING", encoding);
766  else
767  unsetenv("PGCLIENTENCODING");
768 
769  /*
770  * Set timezone and datestyle for datetime-related tests
771  */
772  putenv("PGTZ=PST8PDT");
773  putenv("PGDATESTYLE=Postgres, MDY");
774 
775  /*
776  * Likewise set intervalstyle to ensure consistent results. This is a bit
777  * more painful because we must use PGOPTIONS, and we want to preserve the
778  * user's ability to set other variables through that.
779  */
780  {
781  const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
782  const char *old_pgoptions = getenv("PGOPTIONS");
783  char *new_pgoptions;
784 
785  if (!old_pgoptions)
786  old_pgoptions = "";
787  new_pgoptions = psprintf("PGOPTIONS=%s %s",
788  old_pgoptions, my_pgoptions);
789  putenv(new_pgoptions);
790  }
791 
792  if (temp_instance)
793  {
794  /*
795  * Clear out any environment vars that might cause psql to connect to
796  * the wrong postmaster, or otherwise behave in nondefault ways. (Note
797  * we also use psql's -X switch consistently, so that ~/.psqlrc files
798  * won't mess things up.) Also, set PGPORT to the temp port, and set
799  * PGHOST depending on whether we are using TCP or Unix sockets.
800  */
801  unsetenv("PGDATABASE");
802  unsetenv("PGUSER");
803  unsetenv("PGSERVICE");
804  unsetenv("PGSSLMODE");
805  unsetenv("PGREQUIRESSL");
806  unsetenv("PGCONNECT_TIMEOUT");
807  unsetenv("PGDATA");
808 #ifdef HAVE_UNIX_SOCKETS
809  if (hostname != NULL)
810  doputenv("PGHOST", hostname);
811  else
812  {
813  sockdir = getenv("PG_REGRESS_SOCK_DIR");
814  if (!sockdir)
815  sockdir = make_temp_sockdir();
816  doputenv("PGHOST", sockdir);
817  }
818 #else
819  Assert(hostname != NULL);
820  doputenv("PGHOST", hostname);
821 #endif
822  unsetenv("PGHOSTADDR");
823  if (port != -1)
824  {
825  char s[16];
826 
827  sprintf(s, "%d", port);
828  doputenv("PGPORT", s);
829  }
830  }
831  else
832  {
833  const char *pghost;
834  const char *pgport;
835 
836  /*
837  * When testing an existing install, we honor existing environment
838  * variables, except if they're overridden by command line options.
839  */
840  if (hostname != NULL)
841  {
842  doputenv("PGHOST", hostname);
843  unsetenv("PGHOSTADDR");
844  }
845  if (port != -1)
846  {
847  char s[16];
848 
849  sprintf(s, "%d", port);
850  doputenv("PGPORT", s);
851  }
852  if (user != NULL)
853  doputenv("PGUSER", user);
854 
855  /*
856  * Report what we're connecting to
857  */
858  pghost = getenv("PGHOST");
859  pgport = getenv("PGPORT");
860 #ifndef HAVE_UNIX_SOCKETS
861  if (!pghost)
862  pghost = "localhost";
863 #endif
864 
865  if (pghost && pgport)
866  printf(_("(using postmaster on %s, port %s)\n"), pghost, pgport);
867  if (pghost && !pgport)
868  printf(_("(using postmaster on %s, default port)\n"), pghost);
869  if (!pghost && pgport)
870  printf(_("(using postmaster on Unix socket, port %s)\n"), pgport);
871  if (!pghost && !pgport)
872  printf(_("(using postmaster on Unix socket, default port)\n"));
873  }
874 
876  load_resultmap();
877 }
878 
880 static const char *
881 fmtHba(const char *raw)
882 {
883  static char *ret;
884  const char *rp;
885  char *wp;
886 
887  wp = ret = realloc(ret, 3 + strlen(raw) * 2);
888 
889  *wp++ = '"';
890  for (rp = raw; *rp; rp++)
891  {
892  if (*rp == '"')
893  *wp++ = '"';
894  *wp++ = *rp;
895  }
896  *wp++ = '"';
897  *wp++ = '\0';
898 
899  return ret;
900 }
901 
902 #ifdef ENABLE_SSPI
903 /*
904  * Get account and domain/realm names for the current user. This is based on
905  * pg_SSPI_recvauth(). The returned strings use static storage.
906  */
907 static void
908 current_windows_user(const char **acct, const char **dom)
909 {
910  static char accountname[MAXPGPATH];
911  static char domainname[MAXPGPATH];
912  HANDLE token;
913  TOKEN_USER *tokenuser;
914  DWORD retlen;
915  DWORD accountnamesize = sizeof(accountname);
916  DWORD domainnamesize = sizeof(domainname);
917  SID_NAME_USE accountnameuse;
918 
919  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token))
920  {
921  fprintf(stderr,
922  _("%s: could not open process token: error code %lu\n"),
923  progname, GetLastError());
924  exit(2);
925  }
926 
927  if (!GetTokenInformation(token, TokenUser, NULL, 0, &retlen) && GetLastError() != 122)
928  {
929  fprintf(stderr,
930  _("%s: could not get token information buffer size: error code %lu\n"),
931  progname, GetLastError());
932  exit(2);
933  }
934  tokenuser = pg_malloc(retlen);
935  if (!GetTokenInformation(token, TokenUser, tokenuser, retlen, &retlen))
936  {
937  fprintf(stderr,
938  _("%s: could not get token information: error code %lu\n"),
939  progname, GetLastError());
940  exit(2);
941  }
942 
943  if (!LookupAccountSid(NULL, tokenuser->User.Sid, accountname, &accountnamesize,
944  domainname, &domainnamesize, &accountnameuse))
945  {
946  fprintf(stderr,
947  _("%s: could not look up account SID: error code %lu\n"),
948  progname, GetLastError());
949  exit(2);
950  }
951 
952  free(tokenuser);
953 
954  *acct = accountname;
955  *dom = domainname;
956 }
957 
958 /*
959  * Rewrite pg_hba.conf and pg_ident.conf to use SSPI authentication. Permit
960  * the current OS user to authenticate as the bootstrap superuser and as any
961  * user named in a --create-role option.
962  */
963 static void
964 config_sspi_auth(const char *pgdata)
965 {
966  const char *accountname,
967  *domainname;
968  const char *username;
969  char *errstr;
970  bool have_ipv6;
971  char fname[MAXPGPATH];
972  int res;
973  FILE *hba,
974  *ident;
975  _stringlist *sl;
976 
977  /*
978  * "username", the initdb-chosen bootstrap superuser name, may always
979  * match "accountname", the value SSPI authentication discovers. The
980  * underlying system functions do not clearly guarantee that.
981  */
982  current_windows_user(&accountname, &domainname);
983  username = get_user_name(&errstr);
984  if (username == NULL)
985  {
986  fprintf(stderr, "%s: %s\n", progname, errstr);
987  exit(2);
988  }
989 
990  /*
991  * Like initdb.c:setup_config(), determine whether the platform recognizes
992  * ::1 (IPv6 loopback) as a numeric host address string.
993  */
994  {
995  struct addrinfo *gai_result;
996  struct addrinfo hints;
997  WSADATA wsaData;
998 
999  hints.ai_flags = AI_NUMERICHOST;
1000  hints.ai_family = AF_UNSPEC;
1001  hints.ai_socktype = 0;
1002  hints.ai_protocol = 0;
1003  hints.ai_addrlen = 0;
1004  hints.ai_canonname = NULL;
1005  hints.ai_addr = NULL;
1006  hints.ai_next = NULL;
1007 
1008  have_ipv6 = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0 &&
1009  getaddrinfo("::1", NULL, &hints, &gai_result) == 0);
1010  }
1011 
1012  /* Check a Write outcome and report any error. */
1013 #define CW(cond) \
1014  do { \
1015  if (!(cond)) \
1016  { \
1017  fprintf(stderr, _("%s: could not write to file \"%s\": %s\n"), \
1018  progname, fname, strerror(errno)); \
1019  exit(2); \
1020  } \
1021  } while (0)
1022 
1023  res = snprintf(fname, sizeof(fname), "%s/pg_hba.conf", pgdata);
1024  if (res < 0 || res >= sizeof(fname) - 1)
1025  {
1026  /*
1027  * Truncating this name is a fatal error, because we must not fail to
1028  * overwrite an original trust-authentication pg_hba.conf.
1029  */
1030  fprintf(stderr, _("%s: directory name too long\n"), progname);
1031  exit(2);
1032  }
1033  hba = fopen(fname, "w");
1034  if (hba == NULL)
1035  {
1036  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1037  progname, fname, strerror(errno));
1038  exit(2);
1039  }
1040  CW(fputs("# Configuration written by config_sspi_auth()\n", hba) >= 0);
1041  CW(fputs("host all all 127.0.0.1/32 sspi include_realm=1 map=regress\n",
1042  hba) >= 0);
1043  if (have_ipv6)
1044  CW(fputs("host all all ::1/128 sspi include_realm=1 map=regress\n",
1045  hba) >= 0);
1046  CW(fclose(hba) == 0);
1047 
1048  snprintf(fname, sizeof(fname), "%s/pg_ident.conf", pgdata);
1049  ident = fopen(fname, "w");
1050  if (ident == NULL)
1051  {
1052  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1053  progname, fname, strerror(errno));
1054  exit(2);
1055  }
1056  CW(fputs("# Configuration written by config_sspi_auth()\n", ident) >= 0);
1057 
1058  /*
1059  * Double-quote for the benefit of account names containing whitespace or
1060  * '#'. Windows forbids the double-quote character itself, so don't
1061  * bother escaping embedded double-quote characters.
1062  */
1063  CW(fprintf(ident, "regress \"%s@%s\" %s\n",
1064  accountname, domainname, fmtHba(username)) >= 0);
1065  for (sl = extraroles; sl; sl = sl->next)
1066  CW(fprintf(ident, "regress \"%s@%s\" %s\n",
1067  accountname, domainname, fmtHba(sl->str)) >= 0);
1068  CW(fclose(ident) == 0);
1069 }
1070 #endif
1071 
1072 /*
1073  * Issue a command via psql, connecting to the specified database
1074  *
1075  * Since we use system(), this doesn't return until the operation finishes
1076  */
1077 static void
1078 psql_command(const char *database, const char *query,...)
1079 {
1080  char query_formatted[1024];
1081  char query_escaped[2048];
1082  char psql_cmd[MAXPGPATH + 2048];
1083  va_list args;
1084  char *s;
1085  char *d;
1086 
1087  /* Generate the query with insertion of sprintf arguments */
1088  va_start(args, query);
1089  vsnprintf(query_formatted, sizeof(query_formatted), query, args);
1090  va_end(args);
1091 
1092  /* Now escape any shell double-quote metacharacters */
1093  d = query_escaped;
1094  for (s = query_formatted; *s; s++)
1095  {
1096  if (strchr("\\\"$`", *s))
1097  *d++ = '\\';
1098  *d++ = *s;
1099  }
1100  *d = '\0';
1101 
1102  /* And now we can build and execute the shell command */
1103  snprintf(psql_cmd, sizeof(psql_cmd),
1104  "\"%s%spsql\" -X -c \"%s\" \"%s\"",
1105  bindir ? bindir : "",
1106  bindir ? "/" : "",
1107  query_escaped,
1108  database);
1109 
1110  if (system(psql_cmd) != 0)
1111  {
1112  /* psql probably already reported the error */
1113  fprintf(stderr, _("command failed: %s\n"), psql_cmd);
1114  exit(2);
1115  }
1116 }
1117 
1118 /*
1119  * Spawn a process to execute the given shell command; don't wait for it
1120  *
1121  * Returns the process ID (or HANDLE) so we can wait for it later
1122  */
1123 PID_TYPE
1124 spawn_process(const char *cmdline)
1125 {
1126 #ifndef WIN32
1127  pid_t pid;
1128 
1129  /*
1130  * Must flush I/O buffers before fork. Ideally we'd use fflush(NULL) here
1131  * ... does anyone still care about systems where that doesn't work?
1132  */
1133  fflush(stdout);
1134  fflush(stderr);
1135  if (logfile)
1136  fflush(logfile);
1137 
1138  pid = fork();
1139  if (pid == -1)
1140  {
1141  fprintf(stderr, _("%s: could not fork: %s\n"),
1142  progname, strerror(errno));
1143  exit(2);
1144  }
1145  if (pid == 0)
1146  {
1147  /*
1148  * In child
1149  *
1150  * Instead of using system(), exec the shell directly, and tell it to
1151  * "exec" the command too. This saves two useless processes per
1152  * parallel test case.
1153  */
1154  char *cmdline2;
1155 
1156  cmdline2 = psprintf("exec %s", cmdline);
1157  execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
1158  fprintf(stderr, _("%s: could not exec \"%s\": %s\n"),
1159  progname, shellprog, strerror(errno));
1160  _exit(1); /* not exit() here... */
1161  }
1162  /* in parent */
1163  return pid;
1164 #else
1165  PROCESS_INFORMATION pi;
1166  char *cmdline2;
1167  HANDLE restrictedToken;
1168 
1169  memset(&pi, 0, sizeof(pi));
1170  cmdline2 = psprintf("cmd /c \"%s\"", cmdline);
1171 
1172  if ((restrictedToken =
1173  CreateRestrictedProcess(cmdline2, &pi, progname)) == 0)
1174  exit(2);
1175 
1176  CloseHandle(pi.hThread);
1177  return pi.hProcess;
1178 #endif
1179 }
1180 
1181 /*
1182  * Count bytes in file
1183  */
1184 static long
1185 file_size(const char *file)
1186 {
1187  long r;
1188  FILE *f = fopen(file, "r");
1189 
1190  if (!f)
1191  {
1192  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1193  progname, file, strerror(errno));
1194  return -1;
1195  }
1196  fseek(f, 0, SEEK_END);
1197  r = ftell(f);
1198  fclose(f);
1199  return r;
1200 }
1201 
1202 /*
1203  * Count lines in file
1204  */
1205 static int
1206 file_line_count(const char *file)
1207 {
1208  int c;
1209  int l = 0;
1210  FILE *f = fopen(file, "r");
1211 
1212  if (!f)
1213  {
1214  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1215  progname, file, strerror(errno));
1216  return -1;
1217  }
1218  while ((c = fgetc(f)) != EOF)
1219  {
1220  if (c == '\n')
1221  l++;
1222  }
1223  fclose(f);
1224  return l;
1225 }
1226 
1227 bool
1228 file_exists(const char *file)
1229 {
1230  FILE *f = fopen(file, "r");
1231 
1232  if (!f)
1233  return false;
1234  fclose(f);
1235  return true;
1236 }
1237 
1238 static bool
1239 directory_exists(const char *dir)
1240 {
1241  struct stat st;
1242 
1243  if (stat(dir, &st) != 0)
1244  return false;
1245  if (S_ISDIR(st.st_mode))
1246  return true;
1247  return false;
1248 }
1249 
1250 /* Create a directory */
1251 static void
1252 make_directory(const char *dir)
1253 {
1254  if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
1255  {
1256  fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
1257  progname, dir, strerror(errno));
1258  exit(2);
1259  }
1260 }
1261 
1262 /*
1263  * In: filename.ext, Return: filename_i.ext, where 0 < i <= 9
1264  */
1265 static char *
1266 get_alternative_expectfile(const char *expectfile, int i)
1267 {
1268  char *last_dot;
1269  int ssize = strlen(expectfile) + 2 + 1;
1270  char *tmp;
1271  char *s;
1272 
1273  if (!(tmp = (char *) malloc(ssize)))
1274  return NULL;
1275 
1276  if (!(s = (char *) malloc(ssize)))
1277  {
1278  free(tmp);
1279  return NULL;
1280  }
1281 
1282  strcpy(tmp, expectfile);
1283  last_dot = strrchr(tmp, '.');
1284  if (!last_dot)
1285  {
1286  free(tmp);
1287  free(s);
1288  return NULL;
1289  }
1290  *last_dot = '\0';
1291  snprintf(s, ssize, "%s_%d.%s", tmp, i, last_dot + 1);
1292  free(tmp);
1293  return s;
1294 }
1295 
1296 /*
1297  * Run a "diff" command and also check that it didn't crash
1298  */
1299 static int
1300 run_diff(const char *cmd, const char *filename)
1301 {
1302  int r;
1303 
1304  r = system(cmd);
1305  if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
1306  {
1307  fprintf(stderr, _("diff command failed with status %d: %s\n"), r, cmd);
1308  exit(2);
1309  }
1310 #ifdef WIN32
1311 
1312  /*
1313  * On WIN32, if the 'diff' command cannot be found, system() returns 1,
1314  * but produces nothing to stdout, so we check for that here.
1315  */
1316  if (WEXITSTATUS(r) == 1 && file_size(filename) <= 0)
1317  {
1318  fprintf(stderr, _("diff command not found: %s\n"), cmd);
1319  exit(2);
1320  }
1321 #endif
1322 
1323  return WEXITSTATUS(r);
1324 }
1325 
1326 /*
1327  * Check the actual result file for the given test against expected results
1328  *
1329  * Returns true if different (failure), false if correct match found.
1330  * In the true case, the diff is appended to the diffs file.
1331  */
1332 static bool
1333 results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
1334 {
1335  char expectfile[MAXPGPATH];
1336  char diff[MAXPGPATH];
1337  char cmd[MAXPGPATH * 3];
1338  char best_expect_file[MAXPGPATH];
1339  FILE *difffile;
1340  int best_line_count;
1341  int i;
1342  int l;
1343  const char *platform_expectfile;
1344 
1345  /*
1346  * We can pass either the resultsfile or the expectfile, they should have
1347  * the same type (filename.type) anyway.
1348  */
1349  platform_expectfile = get_expectfile(testname, resultsfile);
1350 
1351  strlcpy(expectfile, default_expectfile, sizeof(expectfile));
1352  if (platform_expectfile)
1353  {
1354  /*
1355  * Replace everything after the last slash in expectfile with what the
1356  * platform_expectfile contains.
1357  */
1358  char *p = strrchr(expectfile, '/');
1359 
1360  if (p)
1361  strcpy(++p, platform_expectfile);
1362  }
1363 
1364  /* Name to use for temporary diff file */
1365  snprintf(diff, sizeof(diff), "%s.diff", resultsfile);
1366 
1367  /* OK, run the diff */
1368  snprintf(cmd, sizeof(cmd),
1369  "diff %s \"%s\" \"%s\" > \"%s\"",
1370  basic_diff_opts, expectfile, resultsfile, diff);
1371 
1372  /* Is the diff file empty? */
1373  if (run_diff(cmd, diff) == 0)
1374  {
1375  unlink(diff);
1376  return false;
1377  }
1378 
1379  /* There may be secondary comparison files that match better */
1380  best_line_count = file_line_count(diff);
1381  strcpy(best_expect_file, expectfile);
1382 
1383  for (i = 0; i <= 9; i++)
1384  {
1385  char *alt_expectfile;
1386 
1387  alt_expectfile = get_alternative_expectfile(expectfile, i);
1388  if (!alt_expectfile)
1389  {
1390  fprintf(stderr, _("Unable to check secondary comparison files: %s\n"),
1391  strerror(errno));
1392  exit(2);
1393  }
1394 
1395  if (!file_exists(alt_expectfile))
1396  {
1397  free(alt_expectfile);
1398  continue;
1399  }
1400 
1401  snprintf(cmd, sizeof(cmd),
1402  "diff %s \"%s\" \"%s\" > \"%s\"",
1403  basic_diff_opts, alt_expectfile, resultsfile, diff);
1404 
1405  if (run_diff(cmd, diff) == 0)
1406  {
1407  unlink(diff);
1408  free(alt_expectfile);
1409  return false;
1410  }
1411 
1412  l = file_line_count(diff);
1413  if (l < best_line_count)
1414  {
1415  /* This diff was a better match than the last one */
1416  best_line_count = l;
1417  strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file));
1418  }
1419  free(alt_expectfile);
1420  }
1421 
1422  /*
1423  * fall back on the canonical results file if we haven't tried it yet and
1424  * haven't found a complete match yet.
1425  */
1426 
1427  if (platform_expectfile)
1428  {
1429  snprintf(cmd, sizeof(cmd),
1430  "diff %s \"%s\" \"%s\" > \"%s\"",
1431  basic_diff_opts, default_expectfile, resultsfile, diff);
1432 
1433  if (run_diff(cmd, diff) == 0)
1434  {
1435  /* No diff = no changes = good */
1436  unlink(diff);
1437  return false;
1438  }
1439 
1440  l = file_line_count(diff);
1441  if (l < best_line_count)
1442  {
1443  /* This diff was a better match than the last one */
1444  best_line_count = l;
1445  strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file));
1446  }
1447  }
1448 
1449  /*
1450  * Use the best comparison file to generate the "pretty" diff, which we
1451  * append to the diffs summary file.
1452  */
1453  snprintf(cmd, sizeof(cmd),
1454  "diff %s \"%s\" \"%s\" >> \"%s\"",
1455  pretty_diff_opts, best_expect_file, resultsfile, difffilename);
1456  run_diff(cmd, difffilename);
1457 
1458  /* And append a separator */
1459  difffile = fopen(difffilename, "a");
1460  if (difffile)
1461  {
1462  fprintf(difffile,
1463  "\n======================================================================\n\n");
1464  fclose(difffile);
1465  }
1466 
1467  unlink(diff);
1468  return true;
1469 }
1470 
1471 /*
1472  * Wait for specified subprocesses to finish, and return their exit
1473  * statuses into statuses[]
1474  *
1475  * If names isn't NULL, print each subprocess's name as it finishes
1476  *
1477  * Note: it's OK to scribble on the pids array, but not on the names array
1478  */
1479 static void
1480 wait_for_tests(PID_TYPE * pids, int *statuses, char **names, int num_tests)
1481 {
1482  int tests_left;
1483  int i;
1484 
1485 #ifdef WIN32
1486  PID_TYPE *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE));
1487 
1488  memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE));
1489 #endif
1490 
1491  tests_left = num_tests;
1492  while (tests_left > 0)
1493  {
1494  PID_TYPE p;
1495 
1496 #ifndef WIN32
1497  int exit_status;
1498 
1499  p = wait(&exit_status);
1500 
1501  if (p == INVALID_PID)
1502  {
1503  fprintf(stderr, _("failed to wait for subprocesses: %s\n"),
1504  strerror(errno));
1505  exit(2);
1506  }
1507 #else
1508  DWORD exit_status;
1509  int r;
1510 
1511  r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE);
1512  if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left)
1513  {
1514  fprintf(stderr, _("failed to wait for subprocesses: error code %lu\n"),
1515  GetLastError());
1516  exit(2);
1517  }
1518  p = active_pids[r - WAIT_OBJECT_0];
1519  /* compact the active_pids array */
1520  active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1];
1521 #endif /* WIN32 */
1522 
1523  for (i = 0; i < num_tests; i++)
1524  {
1525  if (p == pids[i])
1526  {
1527 #ifdef WIN32
1528  GetExitCodeProcess(pids[i], &exit_status);
1529  CloseHandle(pids[i]);
1530 #endif
1531  pids[i] = INVALID_PID;
1532  statuses[i] = (int) exit_status;
1533  if (names)
1534  status(" %s", names[i]);
1535  tests_left--;
1536  break;
1537  }
1538  }
1539  }
1540 
1541 #ifdef WIN32
1542  free(active_pids);
1543 #endif
1544 }
1545 
1546 /*
1547  * report nonzero exit code from a test process
1548  */
1549 static void
1550 log_child_failure(int exitstatus)
1551 {
1552  if (WIFEXITED(exitstatus))
1553  status(_(" (test process exited with exit code %d)"),
1554  WEXITSTATUS(exitstatus));
1555  else if (WIFSIGNALED(exitstatus))
1556  {
1557 #if defined(WIN32)
1558  status(_(" (test process was terminated by exception 0x%X)"),
1559  WTERMSIG(exitstatus));
1560 #elif defined(HAVE_DECL_SYS_SIGLIST) && HAVE_DECL_SYS_SIGLIST
1561  status(_(" (test process was terminated by signal %d: %s)"),
1562  WTERMSIG(exitstatus),
1563  WTERMSIG(exitstatus) < NSIG ?
1564  sys_siglist[WTERMSIG(exitstatus)] : "(unknown))");
1565 #else
1566  status(_(" (test process was terminated by signal %d)"),
1567  WTERMSIG(exitstatus));
1568 #endif
1569  }
1570  else
1571  status(_(" (test process exited with unrecognized status %d)"),
1572  exitstatus);
1573 }
1574 
1575 /*
1576  * Run all the tests specified in one schedule file
1577  */
1578 static void
1579 run_schedule(const char *schedule, test_function tfunc)
1580 {
1581 #define MAX_PARALLEL_TESTS 100
1582  char *tests[MAX_PARALLEL_TESTS];
1583  _stringlist *resultfiles[MAX_PARALLEL_TESTS];
1584  _stringlist *expectfiles[MAX_PARALLEL_TESTS];
1587  int statuses[MAX_PARALLEL_TESTS];
1588  _stringlist *ignorelist = NULL;
1589  char scbuf[1024];
1590  FILE *scf;
1591  int line_num = 0;
1592 
1593  memset(resultfiles, 0, sizeof(_stringlist *) * MAX_PARALLEL_TESTS);
1594  memset(expectfiles, 0, sizeof(_stringlist *) * MAX_PARALLEL_TESTS);
1595  memset(tags, 0, sizeof(_stringlist *) * MAX_PARALLEL_TESTS);
1596 
1597  scf = fopen(schedule, "r");
1598  if (!scf)
1599  {
1600  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1601  progname, schedule, strerror(errno));
1602  exit(2);
1603  }
1604 
1605  while (fgets(scbuf, sizeof(scbuf), scf))
1606  {
1607  char *test = NULL;
1608  char *c;
1609  int num_tests;
1610  bool inword;
1611  int i;
1612 
1613  line_num++;
1614 
1615  for (i = 0; i < MAX_PARALLEL_TESTS; i++)
1616  {
1617  if (resultfiles[i] == NULL)
1618  break;
1619  free_stringlist(&resultfiles[i]);
1620  free_stringlist(&expectfiles[i]);
1621  free_stringlist(&tags[i]);
1622  }
1623 
1624  /* strip trailing whitespace, especially the newline */
1625  i = strlen(scbuf);
1626  while (i > 0 && isspace((unsigned char) scbuf[i - 1]))
1627  scbuf[--i] = '\0';
1628 
1629  if (scbuf[0] == '\0' || scbuf[0] == '#')
1630  continue;
1631  if (strncmp(scbuf, "test: ", 6) == 0)
1632  test = scbuf + 6;
1633  else if (strncmp(scbuf, "ignore: ", 8) == 0)
1634  {
1635  c = scbuf + 8;
1636  while (*c && isspace((unsigned char) *c))
1637  c++;
1638  add_stringlist_item(&ignorelist, c);
1639 
1640  /*
1641  * Note: ignore: lines do not run the test, they just say that
1642  * failure of this test when run later on is to be ignored. A bit
1643  * odd but that's how the shell-script version did it.
1644  */
1645  continue;
1646  }
1647  else
1648  {
1649  fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
1650  schedule, line_num, scbuf);
1651  exit(2);
1652  }
1653 
1654  num_tests = 0;
1655  inword = false;
1656  for (c = test; *c; c++)
1657  {
1658  if (isspace((unsigned char) *c))
1659  {
1660  *c = '\0';
1661  inword = false;
1662  }
1663  else if (!inword)
1664  {
1665  if (num_tests >= MAX_PARALLEL_TESTS)
1666  {
1667  /* can't print scbuf here, it's already been trashed */
1668  fprintf(stderr, _("too many parallel tests in schedule file \"%s\", line %d\n"),
1669  schedule, line_num);
1670  exit(2);
1671  }
1672  tests[num_tests] = c;
1673  num_tests++;
1674  inword = true;
1675  }
1676  }
1677 
1678  if (num_tests == 0)
1679  {
1680  fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
1681  schedule, line_num, scbuf);
1682  exit(2);
1683  }
1684 
1685  if (num_tests == 1)
1686  {
1687  status(_("test %-24s ... "), tests[0]);
1688  pids[0] = (tfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]);
1689  wait_for_tests(pids, statuses, NULL, 1);
1690  /* status line is finished below */
1691  }
1692  else if (max_connections > 0 && max_connections < num_tests)
1693  {
1694  int oldest = 0;
1695 
1696  status(_("parallel group (%d tests, in groups of %d): "),
1697  num_tests, max_connections);
1698  for (i = 0; i < num_tests; i++)
1699  {
1700  if (i - oldest >= max_connections)
1701  {
1702  wait_for_tests(pids + oldest, statuses + oldest,
1703  tests + oldest, i - oldest);
1704  oldest = i;
1705  }
1706  pids[i] = (tfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1707  }
1708  wait_for_tests(pids + oldest, statuses + oldest,
1709  tests + oldest, i - oldest);
1710  status_end();
1711  }
1712  else
1713  {
1714  status(_("parallel group (%d tests): "), num_tests);
1715  for (i = 0; i < num_tests; i++)
1716  {
1717  pids[i] = (tfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1718  }
1719  wait_for_tests(pids, statuses, tests, num_tests);
1720  status_end();
1721  }
1722 
1723  /* Check results for all tests */
1724  for (i = 0; i < num_tests; i++)
1725  {
1726  _stringlist *rl,
1727  *el,
1728  *tl;
1729  bool differ = false;
1730 
1731  if (num_tests > 1)
1732  status(_(" %-24s ... "), tests[i]);
1733 
1734  /*
1735  * Advance over all three lists simultaneously.
1736  *
1737  * Compare resultfiles[j] with expectfiles[j] always. Tags are
1738  * optional but if there are tags, the tag list has the same
1739  * length as the other two lists.
1740  */
1741  for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i];
1742  rl != NULL; /* rl and el have the same length */
1743  rl = rl->next, el = el->next)
1744  {
1745  bool newdiff;
1746 
1747  if (tl)
1748  tl = tl->next; /* tl has the same length as rl and el
1749  * if it exists */
1750 
1751  newdiff = results_differ(tests[i], rl->str, el->str);
1752  if (newdiff && tl)
1753  {
1754  printf("%s ", tl->str);
1755  }
1756  differ |= newdiff;
1757  }
1758 
1759  if (differ)
1760  {
1761  bool ignore = false;
1762  _stringlist *sl;
1763 
1764  for (sl = ignorelist; sl != NULL; sl = sl->next)
1765  {
1766  if (strcmp(tests[i], sl->str) == 0)
1767  {
1768  ignore = true;
1769  break;
1770  }
1771  }
1772  if (ignore)
1773  {
1774  status(_("failed (ignored)"));
1776  }
1777  else
1778  {
1779  status(_("FAILED"));
1780  fail_count++;
1781  }
1782  }
1783  else
1784  {
1785  status(_("ok"));
1786  success_count++;
1787  }
1788 
1789  if (statuses[i] != 0)
1790  log_child_failure(statuses[i]);
1791 
1792  status_end();
1793  }
1794  }
1795 
1796  free_stringlist(&ignorelist);
1797 
1798  fclose(scf);
1799 }
1800 
1801 /*
1802  * Run a single test
1803  */
1804 static void
1806 {
1807  PID_TYPE pid;
1808  int exit_status;
1809  _stringlist *resultfiles = NULL;
1810  _stringlist *expectfiles = NULL;
1811  _stringlist *tags = NULL;
1812  _stringlist *rl,
1813  *el,
1814  *tl;
1815  bool differ = false;
1816 
1817  status(_("test %-24s ... "), test);
1818  pid = (tfunc) (test, &resultfiles, &expectfiles, &tags);
1819  wait_for_tests(&pid, &exit_status, NULL, 1);
1820 
1821  /*
1822  * Advance over all three lists simultaneously.
1823  *
1824  * Compare resultfiles[j] with expectfiles[j] always. Tags are optional
1825  * but if there are tags, the tag list has the same length as the other
1826  * two lists.
1827  */
1828  for (rl = resultfiles, el = expectfiles, tl = tags;
1829  rl != NULL; /* rl and el have the same length */
1830  rl = rl->next, el = el->next)
1831  {
1832  bool newdiff;
1833 
1834  if (tl)
1835  tl = tl->next; /* tl has the same length as rl and el if it
1836  * exists */
1837 
1838  newdiff = results_differ(test, rl->str, el->str);
1839  if (newdiff && tl)
1840  {
1841  printf("%s ", tl->str);
1842  }
1843  differ |= newdiff;
1844  }
1845 
1846  if (differ)
1847  {
1848  status(_("FAILED"));
1849  fail_count++;
1850  }
1851  else
1852  {
1853  status(_("ok"));
1854  success_count++;
1855  }
1856 
1857  if (exit_status != 0)
1858  log_child_failure(exit_status);
1859 
1860  status_end();
1861 }
1862 
1863 /*
1864  * Create the summary-output files (making them empty if already existing)
1865  */
1866 static void
1868 {
1869  char file[MAXPGPATH];
1870  FILE *difffile;
1871 
1872  /* create the log file (copy of running status output) */
1873  snprintf(file, sizeof(file), "%s/regression.out", outputdir);
1874  logfilename = pg_strdup(file);
1875  logfile = fopen(logfilename, "w");
1876  if (!logfile)
1877  {
1878  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1879  progname, logfilename, strerror(errno));
1880  exit(2);
1881  }
1882 
1883  /* create the diffs file as empty */
1884  snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
1885  difffilename = pg_strdup(file);
1886  difffile = fopen(difffilename, "w");
1887  if (!difffile)
1888  {
1889  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1890  progname, difffilename, strerror(errno));
1891  exit(2);
1892  }
1893  /* we don't keep the diffs file open continuously */
1894  fclose(difffile);
1895 
1896  /* also create the output directory if not present */
1897  snprintf(file, sizeof(file), "%s/results", outputdir);
1898  if (!directory_exists(file))
1899  make_directory(file);
1900 }
1901 
1902 static void
1904 {
1905  header(_("dropping database \"%s\""), dbname);
1906  psql_command("postgres", "DROP DATABASE IF EXISTS \"%s\"", dbname);
1907 }
1908 
1909 static void
1911 {
1912  _stringlist *sl;
1913 
1914  /*
1915  * We use template0 so that any installation-local cruft in template1 will
1916  * not mess up the tests.
1917  */
1918  header(_("creating database \"%s\""), dbname);
1919  if (encoding)
1920  psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
1921  (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
1922  else
1923  psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
1924  (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
1925  psql_command(dbname,
1926  "ALTER DATABASE \"%s\" SET lc_messages TO 'C';"
1927  "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';"
1928  "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';"
1929  "ALTER DATABASE \"%s\" SET lc_time TO 'C';"
1930  "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';",
1931  dbname, dbname, dbname, dbname, dbname);
1932 
1933  /*
1934  * Install any requested procedural languages. We use CREATE OR REPLACE
1935  * so that this will work whether or not the language is preinstalled.
1936  */
1937  for (sl = loadlanguage; sl != NULL; sl = sl->next)
1938  {
1939  header(_("installing %s"), sl->str);
1940  psql_command(dbname, "CREATE OR REPLACE LANGUAGE \"%s\"", sl->str);
1941  }
1942 
1943  /*
1944  * Install any requested extensions. We use CREATE IF NOT EXISTS so that
1945  * this will work whether or not the extension is preinstalled.
1946  */
1947  for (sl = loadextension; sl != NULL; sl = sl->next)
1948  {
1949  header(_("installing %s"), sl->str);
1950  psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
1951  }
1952 }
1953 
1954 static void
1955 drop_role_if_exists(const char *rolename)
1956 {
1957  header(_("dropping role \"%s\""), rolename);
1958  psql_command("postgres", "DROP ROLE IF EXISTS \"%s\"", rolename);
1959 }
1960 
1961 static void
1962 create_role(const char *rolename, const _stringlist *granted_dbs)
1963 {
1964  header(_("creating role \"%s\""), rolename);
1965  psql_command("postgres", "CREATE ROLE \"%s\" WITH LOGIN", rolename);
1966  for (; granted_dbs != NULL; granted_dbs = granted_dbs->next)
1967  {
1968  psql_command("postgres", "GRANT ALL ON DATABASE \"%s\" TO \"%s\"",
1969  granted_dbs->str, rolename);
1970  }
1971 }
1972 
1973 static void
1974 help(void)
1975 {
1976  printf(_("PostgreSQL regression test driver\n"));
1977  printf(_("\n"));
1978  printf(_("Usage:\n %s [OPTION]... [EXTRA-TEST]...\n"), progname);
1979  printf(_("\n"));
1980  printf(_("Options:\n"));
1981  printf(_(" --config-auth=DATADIR update authentication settings for DATADIR\n"));
1982  printf(_(" --create-role=ROLE create the specified role before testing\n"));
1983  printf(_(" --dbname=DB use database DB (default \"regression\")\n"));
1984  printf(_(" --debug turn on debug mode in programs that are run\n"));
1985  printf(_(" --dlpath=DIR look for dynamic libraries in DIR\n"));
1986  printf(_(" --encoding=ENCODING use ENCODING as the encoding\n"));
1987  printf(_(" --inputdir=DIR take input files from DIR (default \".\")\n"));
1988  printf(_(" --launcher=CMD use CMD as launcher of psql\n"));
1989  printf(_(" --load-extension=EXT load the named extension before running the\n"));
1990  printf(_(" tests; can appear multiple times\n"));
1991  printf(_(" --load-language=LANG load the named language before running the\n"));
1992  printf(_(" tests; can appear multiple times\n"));
1993  printf(_(" --max-connections=N maximum number of concurrent connections\n"));
1994  printf(_(" (default is 0, meaning unlimited)\n"));
1995  printf(_(" --outputdir=DIR place output files in DIR (default \".\")\n"));
1996  printf(_(" --schedule=FILE use test ordering schedule from FILE\n"));
1997  printf(_(" (can be used multiple times to concatenate)\n"));
1998  printf(_(" --temp-instance=DIR create a temporary instance in DIR\n"));
1999  printf(_(" --use-existing use an existing installation\n"));
2000  printf(_("\n"));
2001  printf(_("Options for \"temp-instance\" mode:\n"));
2002  printf(_(" --no-locale use C locale\n"));
2003  printf(_(" --port=PORT start postmaster on PORT\n"));
2004  printf(_(" --temp-config=FILE append contents of FILE to temporary config\n"));
2005  printf(_("\n"));
2006  printf(_("Options for using an existing installation:\n"));
2007  printf(_(" --host=HOST use postmaster running on HOST\n"));
2008  printf(_(" --port=PORT use postmaster running at PORT\n"));
2009  printf(_(" --user=USER connect as USER\n"));
2010  printf(_("\n"));
2011  printf(_("The exit status is 0 if all tests passed, 1 if some tests failed, and 2\n"));
2012  printf(_("if the tests could not be run for some reason.\n"));
2013  printf(_("\n"));
2014  printf(_("Report bugs to <pgsql-bugs@postgresql.org>.\n"));
2015 }
2016 
2017 int
2018 regression_main(int argc, char *argv[], init_function ifunc, test_function tfunc)
2019 {
2020  static struct option long_options[] = {
2021  {"help", no_argument, NULL, 'h'},
2022  {"version", no_argument, NULL, 'V'},
2023  {"dbname", required_argument, NULL, 1},
2024  {"debug", no_argument, NULL, 2},
2025  {"inputdir", required_argument, NULL, 3},
2026  {"load-language", required_argument, NULL, 4},
2027  {"max-connections", required_argument, NULL, 5},
2028  {"encoding", required_argument, NULL, 6},
2029  {"outputdir", required_argument, NULL, 7},
2030  {"schedule", required_argument, NULL, 8},
2031  {"temp-instance", required_argument, NULL, 9},
2032  {"no-locale", no_argument, NULL, 10},
2033  {"host", required_argument, NULL, 13},
2034  {"port", required_argument, NULL, 14},
2035  {"user", required_argument, NULL, 15},
2036  {"bindir", required_argument, NULL, 16},
2037  {"dlpath", required_argument, NULL, 17},
2038  {"create-role", required_argument, NULL, 18},
2039  {"temp-config", required_argument, NULL, 19},
2040  {"use-existing", no_argument, NULL, 20},
2041  {"launcher", required_argument, NULL, 21},
2042  {"load-extension", required_argument, NULL, 22},
2043  {"config-auth", required_argument, NULL, 24},
2044  {NULL, 0, NULL, 0}
2045  };
2046 
2047  _stringlist *sl;
2048  int c;
2049  int i;
2050  int option_index;
2051  char buf[MAXPGPATH * 4];
2052  char buf2[MAXPGPATH * 4];
2053 
2054  progname = get_progname(argv[0]);
2055  set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
2056 
2057  atexit(stop_postmaster);
2058 
2059 #ifndef HAVE_UNIX_SOCKETS
2060  /* no unix domain sockets available, so change default */
2061  hostname = "localhost";
2062 #endif
2063 
2064  /*
2065  * We call the initialization function here because that way we can set
2066  * default parameters and let them be overwritten by the commandline.
2067  */
2068  ifunc(argc, argv);
2069 
2070  if (getenv("PG_REGRESS_DIFF_OPTS"))
2071  pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
2072 
2073  while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
2074  {
2075  switch (c)
2076  {
2077  case 'h':
2078  help();
2079  exit(0);
2080  case 'V':
2081  puts("pg_regress (PostgreSQL) " PG_VERSION);
2082  exit(0);
2083  case 1:
2084 
2085  /*
2086  * If a default database was specified, we need to remove it
2087  * before we add the specified one.
2088  */
2089  free_stringlist(&dblist);
2090  split_to_stringlist(optarg, ",", &dblist);
2091  break;
2092  case 2:
2093  debug = true;
2094  break;
2095  case 3:
2097  break;
2098  case 4:
2099  add_stringlist_item(&loadlanguage, optarg);
2100  break;
2101  case 5:
2102  max_connections = atoi(optarg);
2103  break;
2104  case 6:
2106  break;
2107  case 7:
2109  break;
2110  case 8:
2111  add_stringlist_item(&schedulelist, optarg);
2112  break;
2113  case 9:
2115  break;
2116  case 10:
2117  nolocale = true;
2118  break;
2119  case 13:
2121  break;
2122  case 14:
2123  port = atoi(optarg);
2124  port_specified_by_user = true;
2125  break;
2126  case 15:
2127  user = pg_strdup(optarg);
2128  break;
2129  case 16:
2130  /* "--bindir=" means to use PATH */
2131  if (strlen(optarg))
2132  bindir = pg_strdup(optarg);
2133  else
2134  bindir = NULL;
2135  break;
2136  case 17:
2137  dlpath = pg_strdup(optarg);
2138  break;
2139  case 18:
2140  split_to_stringlist(optarg, ",", &extraroles);
2141  break;
2142  case 19:
2143  add_stringlist_item(&temp_configs, optarg);
2144  break;
2145  case 20:
2146  use_existing = true;
2147  break;
2148  case 21:
2150  break;
2151  case 22:
2152  add_stringlist_item(&loadextension, optarg);
2153  break;
2154  case 24:
2156  break;
2157  default:
2158  /* getopt_long already emitted a complaint */
2159  fprintf(stderr, _("\nTry \"%s -h\" for more information.\n"),
2160  progname);
2161  exit(2);
2162  }
2163  }
2164 
2165  /*
2166  * if we still have arguments, they are extra tests to run
2167  */
2168  while (argc - optind >= 1)
2169  {
2170  add_stringlist_item(&extra_tests, argv[optind]);
2171  optind++;
2172  }
2173 
2174  if (config_auth_datadir)
2175  {
2176 #ifdef ENABLE_SSPI
2177  config_sspi_auth(config_auth_datadir);
2178 #endif
2179  exit(0);
2180  }
2181 
2183 
2184  /*
2185  * To reduce chances of interference with parallel installations, use
2186  * a port number starting in the private range (49152-65535)
2187  * calculated from the version number. This aids !HAVE_UNIX_SOCKETS
2188  * systems; elsewhere, the use of a private socket directory already
2189  * prevents interference.
2190  */
2191  port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
2192 
2196 
2197  /*
2198  * Initialization
2199  */
2201 
2203 
2204 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
2205  unlimit_core_size();
2206 #endif
2207 
2208  if (temp_instance)
2209  {
2210  FILE *pg_conf;
2211  const char *env_wait;
2212  int wait_seconds;
2213 
2214  /*
2215  * Prepare the temp instance
2216  */
2217 
2219  {
2220  header(_("removing existing temp instance"));
2221  if (!rmtree(temp_instance, true))
2222  {
2223  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2225  exit(2);
2226  }
2227  }
2228 
2229  header(_("creating temporary instance"));
2230 
2231  /* make the temp instance top directory */
2233 
2234  /* and a directory for log files */
2235  snprintf(buf, sizeof(buf), "%s/log", outputdir);
2236  if (!directory_exists(buf))
2237  make_directory(buf);
2238 
2239  /* initdb */
2240  header(_("initializing database system"));
2241  snprintf(buf, sizeof(buf),
2242  "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync%s%s > \"%s/log/initdb.log\" 2>&1",
2243  bindir ? bindir : "",
2244  bindir ? "/" : "",
2245  temp_instance,
2246  debug ? " --debug" : "",
2247  nolocale ? " --no-locale" : "",
2248  outputdir);
2249  if (system(buf))
2250  {
2251  fprintf(stderr, _("\n%s: initdb failed\nExamine %s/log/initdb.log for the reason.\nCommand was: %s\n"), progname, outputdir, buf);
2252  exit(2);
2253  }
2254 
2255  /*
2256  * Adjust the default postgresql.conf for regression testing. The user
2257  * can specify a file to be appended; in any case we expand logging
2258  * and set max_prepared_transactions to enable testing of prepared
2259  * xacts. (Note: to reduce the probability of unexpected shmmax
2260  * failures, don't set max_prepared_transactions any higher than
2261  * actually needed by the prepared_xacts regression test.)
2262  */
2263  snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
2264  pg_conf = fopen(buf, "a");
2265  if (pg_conf == NULL)
2266  {
2267  fprintf(stderr, _("\n%s: could not open \"%s\" for adding extra config: %s\n"), progname, buf, strerror(errno));
2268  exit(2);
2269  }
2270  fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
2271  fputs("log_autovacuum_min_duration = 0\n", pg_conf);
2272  fputs("log_checkpoints = on\n", pg_conf);
2273  fputs("log_line_prefix = '%m [%p] %q%a '\n", pg_conf);
2274  fputs("log_lock_waits = on\n", pg_conf);
2275  fputs("log_temp_files = 128kB\n", pg_conf);
2276  fputs("max_prepared_transactions = 2\n", pg_conf);
2277 
2278  for (sl = temp_configs; sl != NULL; sl = sl->next)
2279  {
2280  char *temp_config = sl->str;
2281  FILE *extra_conf;
2282  char line_buf[1024];
2283 
2284  extra_conf = fopen(temp_config, "r");
2285  if (extra_conf == NULL)
2286  {
2287  fprintf(stderr, _("\n%s: could not open \"%s\" to read extra config: %s\n"), progname, temp_config, strerror(errno));
2288  exit(2);
2289  }
2290  while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
2291  fputs(line_buf, pg_conf);
2292  fclose(extra_conf);
2293  }
2294 
2295  fclose(pg_conf);
2296 
2297 #ifdef ENABLE_SSPI
2298 
2299  /*
2300  * Since we successfully used the same buffer for the much-longer
2301  * "initdb" command, this can't truncate.
2302  */
2303  snprintf(buf, sizeof(buf), "%s/data", temp_instance);
2304  config_sspi_auth(buf);
2305 #elif !defined(HAVE_UNIX_SOCKETS)
2306 #error Platform has no means to secure the test installation.
2307 #endif
2308 
2309  /*
2310  * Check if there is a postmaster running already.
2311  */
2312  snprintf(buf2, sizeof(buf2),
2313  "\"%s%spsql\" -X postgres <%s 2>%s",
2314  bindir ? bindir : "",
2315  bindir ? "/" : "",
2316  DEVNULL, DEVNULL);
2317 
2318  for (i = 0; i < 16; i++)
2319  {
2320  if (system(buf2) == 0)
2321  {
2322  char s[16];
2323 
2324  if (port_specified_by_user || i == 15)
2325  {
2326  fprintf(stderr, _("port %d apparently in use\n"), port);
2328  fprintf(stderr, _("%s: could not determine an available port\n"), progname);
2329  fprintf(stderr, _("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.\n"));
2330  exit(2);
2331  }
2332 
2333  fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
2334  port++;
2335  sprintf(s, "%d", port);
2336  doputenv("PGPORT", s);
2337  }
2338  else
2339  break;
2340  }
2341 
2342  /*
2343  * Start the temp postmaster
2344  */
2345  header(_("starting postmaster"));
2346  snprintf(buf, sizeof(buf),
2347  "\"%s%spostgres\" -D \"%s/data\" -F%s "
2348  "-c \"listen_addresses=%s\" -k \"%s\" "
2349  "> \"%s/log/postmaster.log\" 2>&1",
2350  bindir ? bindir : "",
2351  bindir ? "/" : "",
2352  temp_instance, debug ? " -d 5" : "",
2353  hostname ? hostname : "", sockdir ? sockdir : "",
2354  outputdir);
2356  if (postmaster_pid == INVALID_PID)
2357  {
2358  fprintf(stderr, _("\n%s: could not spawn postmaster: %s\n"),
2359  progname, strerror(errno));
2360  exit(2);
2361  }
2362 
2363  /*
2364  * Wait till postmaster is able to accept connections; normally this
2365  * is only a second or so, but Cygwin is reportedly *much* slower, and
2366  * test builds using Valgrind or similar tools might be too. Hence,
2367  * allow the default timeout of 60 seconds to be overridden from the
2368  * PGCTLTIMEOUT environment variable.
2369  */
2370  env_wait = getenv("PGCTLTIMEOUT");
2371  if (env_wait != NULL)
2372  {
2373  wait_seconds = atoi(env_wait);
2374  if (wait_seconds <= 0)
2375  wait_seconds = 60;
2376  }
2377  else
2378  wait_seconds = 60;
2379 
2380  for (i = 0; i < wait_seconds; i++)
2381  {
2382  /* Done if psql succeeds */
2383  if (system(buf2) == 0)
2384  break;
2385 
2386  /*
2387  * Fail immediately if postmaster has exited
2388  */
2389 #ifndef WIN32
2390  if (kill(postmaster_pid, 0) != 0)
2391 #else
2392  if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
2393 #endif
2394  {
2395  fprintf(stderr, _("\n%s: postmaster failed\nExamine %s/log/postmaster.log for the reason\n"), progname, outputdir);
2396  exit(2);
2397  }
2398 
2399  pg_usleep(1000000L);
2400  }
2401  if (i >= wait_seconds)
2402  {
2403  fprintf(stderr, _("\n%s: postmaster did not respond within %d seconds\nExamine %s/log/postmaster.log for the reason\n"),
2404  progname, wait_seconds, outputdir);
2405 
2406  /*
2407  * If we get here, the postmaster is probably wedged somewhere in
2408  * startup. Try to kill it ungracefully rather than leaving a
2409  * stuck postmaster that might interfere with subsequent test
2410  * attempts.
2411  */
2412 #ifndef WIN32
2413  if (kill(postmaster_pid, SIGKILL) != 0 &&
2414  errno != ESRCH)
2415  fprintf(stderr, _("\n%s: could not kill failed postmaster: %s\n"),
2416  progname, strerror(errno));
2417 #else
2418  if (TerminateProcess(postmaster_pid, 255) == 0)
2419  fprintf(stderr, _("\n%s: could not kill failed postmaster: error code %lu\n"),
2420  progname, GetLastError());
2421 #endif
2422 
2423  exit(2);
2424  }
2425 
2426  postmaster_running = true;
2427 
2428 #ifdef _WIN64
2429 /* need a series of two casts to convert HANDLE without compiler warning */
2430 #define ULONGPID(x) (unsigned long) (unsigned long long) (x)
2431 #else
2432 #define ULONGPID(x) (unsigned long) (x)
2433 #endif
2434  printf(_("running on port %d with PID %lu\n"),
2436  }
2437  else
2438  {
2439  /*
2440  * Using an existing installation, so may need to get rid of
2441  * pre-existing database(s) and role(s)
2442  */
2443  if (!use_existing)
2444  {
2445  for (sl = dblist; sl; sl = sl->next)
2447  for (sl = extraroles; sl; sl = sl->next)
2448  drop_role_if_exists(sl->str);
2449  }
2450  }
2451 
2452  /*
2453  * Create the test database(s) and role(s)
2454  */
2455  if (!use_existing)
2456  {
2457  for (sl = dblist; sl; sl = sl->next)
2458  create_database(sl->str);
2459  for (sl = extraroles; sl; sl = sl->next)
2460  create_role(sl->str, dblist);
2461  }
2462 
2463  /*
2464  * Ready to run the tests
2465  */
2466  header(_("running regression test queries"));
2467 
2468  for (sl = schedulelist; sl != NULL; sl = sl->next)
2469  {
2470  run_schedule(sl->str, tfunc);
2471  }
2472 
2473  for (sl = extra_tests; sl != NULL; sl = sl->next)
2474  {
2475  run_single_test(sl->str, tfunc);
2476  }
2477 
2478  /*
2479  * Shut down temp installation's postmaster
2480  */
2481  if (temp_instance)
2482  {
2483  header(_("shutting down postmaster"));
2484  stop_postmaster();
2485  }
2486 
2487  /*
2488  * If there were no errors, remove the temp instance immediately to
2489  * conserve disk space. (If there were errors, we leave the instance in
2490  * place for possible manual investigation.)
2491  */
2492  if (temp_instance && fail_count == 0 && fail_ignore_count == 0)
2493  {
2494  header(_("removing temporary instance"));
2495  if (!rmtree(temp_instance, true))
2496  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2498  }
2499 
2500  fclose(logfile);
2501 
2502  /*
2503  * Emit nice-looking summary message
2504  */
2505  if (fail_count == 0 && fail_ignore_count == 0)
2506  snprintf(buf, sizeof(buf),
2507  _(" All %d tests passed. "),
2508  success_count);
2509  else if (fail_count == 0) /* fail_count=0, fail_ignore_count>0 */
2510  snprintf(buf, sizeof(buf),
2511  _(" %d of %d tests passed, %d failed test(s) ignored. "),
2512  success_count,
2515  else if (fail_ignore_count == 0) /* fail_count>0 && fail_ignore_count=0 */
2516  snprintf(buf, sizeof(buf),
2517  _(" %d of %d tests failed. "),
2518  fail_count,
2520  else
2521  /* fail_count>0 && fail_ignore_count>0 */
2522  snprintf(buf, sizeof(buf),
2523  _(" %d of %d tests failed, %d of these failures ignored. "),
2527 
2528  putchar('\n');
2529  for (i = strlen(buf); i > 0; i--)
2530  putchar('=');
2531  printf("\n%s\n", buf);
2532  for (i = strlen(buf); i > 0; i--)
2533  putchar('=');
2534  putchar('\n');
2535  putchar('\n');
2536 
2537  if (file_size(difffilename) > 0)
2538  {
2539  printf(_("The differences that caused some tests to fail can be viewed in the\n"
2540  "file \"%s\". A copy of the test summary that you see\n"
2541  "above is saved in the file \"%s\".\n\n"),
2543  }
2544  else
2545  {
2548  }
2549 
2550  if (fail_count != 0)
2551  exit(1);
2552 
2553  return 0;
2554 }
static char * shellprog
Definition: pg_regress.c:53
char * make_absolute_path(const char *path)
Definition: path.c:608
#define getaddrinfo
Definition: getaddrinfo.h:138
static char * get_alternative_expectfile(const char *expectfile, int i)
Definition: pg_regress.c:1266
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1239
static void drop_role_if_exists(const char *rolename)
Definition: pg_regress.c:1955
static void drop_database_if_exists(const char *dbname)
Definition: pg_regress.c:1903
#define UNIXSOCK_PATH(path, port, sockdir)
Definition: pqcomm.h:70
char ** pgfnames(const char *path)
Definition: pgfnames.c:31
static void test(void)
static const char * sockdir
Definition: pg_regress.c:99
static int wait_seconds
Definition: pg_ctl.c:75
static void help(void)
Definition: pg_regress.c:1974
static _stringlist * extra_tests
Definition: pg_regress.c:81
static void log_child_failure(int exitstatus)
Definition: pg_regress.c:1550
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * str
Definition: pg_regress.h:25
static void initialize_environment(void)
Definition: pg_regress.c:722
static void run_single_test(const char *test, test_function tfunc)
Definition: pg_regress.c:1805
char * host_platform
Definition: pg_regress.c:50
bool debug
Definition: pg_regress.c:71
const char * get_progname(const char *argv0)
Definition: path.c:453
static void static void static void void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:152
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:57
#define mkdir(a, b)
Definition: win32.h:65
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
static void run_schedule(const char *schedule, test_function tfunc)
Definition: pg_regress.c:1579
static char * encoding
Definition: pg_regress.c:79
static const char * progname
Definition: pg_regress.c:95
struct _resultmap * next
Definition: pg_regress.c:44
static void make_directory(const char *dir)
Definition: pg_regress.c:1252
static void status_end(void)
Definition: pg_regress.c:243
#define WIFEXITED(w)
Definition: win32.h:180
static bool use_existing
Definition: pg_regress.c:85
static bool postmaster_running
Definition: pg_regress.c:109
#define PID_TYPE
Definition: pg_regress.h:15
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
static FILE * logfile
Definition: pg_regress.c:97
static bool string_matches_pattern(const char *str, const char *pattern)
Definition: pg_regress.c:373
#define putenv(x)
Definition: win32.h:421
static void stop_postmaster(void)
Definition: pg_regress.c:255
#define AI_NUMERICHOST
Definition: getaddrinfo.h:75
static char * temp_instance
Definition: pg_regress.c:82
char * launcher
Definition: pg_regress.c:75
static void convert_sourcefiles(void)
Definition: pg_regress.c:579
static bool results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
Definition: pg_regress.c:1333
static void split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
Definition: pg_regress.c:188
void replace_string(char *string, char *replace, char *replacement)
Definition: pg_regress.c:438
#define pg_attribute_printf(f, a)
Definition: c.h:634
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:173
static _stringlist * loadlanguage
Definition: pg_regress.c:76
PID_TYPE spawn_process(const char *cmdline)
Definition: pg_regress.c:1124
const char * get_user_name(char **errstr)
Definition: username.c:33
#define malloc(a)
Definition: header.h:45
int int vsnprintf(char *str, size_t count, const char *fmt, va_list args)
static char * difffilename
Definition: pg_regress.c:98
void pg_usleep(long microsec)
Definition: signal.c:53
#define required_argument
Definition: getopt_long.h:25
static _resultmap * resultmap
Definition: pg_regress.c:106
int optind
Definition: getopt.c:51
#define WIFSIGNALED(w)
Definition: win32.h:181
static _stringlist * loadextension
Definition: pg_regress.c:77
#define FALSE
Definition: c.h:218
#define MAXPGPATH
static void static void static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1078
_stringlist * dblist
Definition: pg_regress.c:70
char * ai_canonname
Definition: getaddrinfo.h:108
static _stringlist * extraroles
Definition: pg_regress.c:91
static _stringlist * temp_configs
Definition: pg_regress.c:83
char * c
const char * pretty_diff_opts
Definition: pg_regress.c:63
static char * buf
Definition: pg_test_fsync.c:65
#define MAX_PARALLEL_TESTS
#define INVALID_PID
Definition: pg_regress.h:16
static void create_role(const char *rolename, const _stringlist *granted_dbs)
Definition: pg_regress.c:1962
static char * dlpath
Definition: pg_regress.c:89
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static int success_count
Definition: pg_regress.c:111
#define DEVNULL
Definition: port.h:116
static int run_diff(const char *cmd, const char *filename)
Definition: pg_regress.c:1300
int unlink(const char *filename)
static int max_connections
Definition: pg_regress.c:78
static int port
Definition: pg_regress.c:87
static PID_TYPE postmaster_pid
Definition: pg_regress.c:108
char * pghost
Definition: pgbench.c:180
bool rmtree(const char *path, bool rmtopdir)
Definition: rmtree.c:36
#define no_argument
Definition: getopt_long.h:24
static char * config_auth_datadir
Definition: pg_regress.c:92
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1012
static int fail_ignore_count
Definition: pg_regress.c:113
static int fail_count
Definition: pg_regress.c:112
char * outputdir
Definition: pg_regress.c:73
static char * logfilename
Definition: pg_regress.c:96
char * test
Definition: pg_regress.c:41
#define SIGPIPE
Definition: win32.h:201
#define S_IRWXO
Definition: win32.h:484
#define SIGHUP
Definition: win32.h:196
static char * username
Definition: initdb.c:130
#define SIG_DFL
Definition: win32.h:191
static void convert_sourcefiles_in(char *source_subdir, char *dest_dir, char *dest_subdir, char *suffix)
Definition: pg_regress.c:460
char * type
Definition: pg_regress.c:42
char * inputdir
Definition: pg_regress.c:72
static void infile(const char *filename)
Definition: zic.c:1151
pqsigfunc pqsignal(int signum, pqsigfunc handler)
Definition: signal.c:168
#define free(a)
Definition: header.h:60
int ai_protocol
Definition: getaddrinfo.h:105
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
static long file_size(const char *file)
Definition: pg_regress.c:1185
#define WEXITSTATUS(w)
Definition: win32.h:182
#define NULL
Definition: c.h:226
#define Assert(condition)
Definition: c.h:671
void pgfnames_cleanup(char **filenames)
Definition: pgfnames.c:99
static bool port_specified_by_user
Definition: pg_regress.c:88
static const char * get_expectfile(const char *testname, const char *file)
Definition: pg_regress.c:681
char * bindir
Definition: pg_regress.c:74
static int file_line_count(const char *file)
Definition: pg_regress.c:1206
int ai_socktype
Definition: getaddrinfo.h:104
char * dbname
Definition: streamutil.c:41
static void load_resultmap(void)
Definition: pg_regress.c:599
char * mkdtemp(char *path)
Definition: mkdtemp.c:286
PID_TYPE(* test_function)(const char *, _stringlist **, _stringlist **, _stringlist **)
Definition: pg_regress.h:29
#define unsetenv(x)
Definition: win32.h:422
#define realloc(a, b)
Definition: header.h:55
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:205
const char * name
Definition: encode.c:521
char * resultfile
Definition: pg_regress.c:43
#define S_IRWXG
Definition: win32.h:480
static void doputenv(const char *var, const char *val)
Definition: pg_regress.c:710
struct _resultmap _resultmap
static char * filename
Definition: pg_dumpall.c:84
struct addrinfo * ai_next
Definition: getaddrinfo.h:109
static char * user
Definition: pg_regress.c:90
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:550
char * optarg
Definition: getopt.c:53
static _stringlist * schedulelist
Definition: pg_regress.c:80
bool file_exists(const char *file)
Definition: pg_regress.c:1228
struct _stringlist * next
Definition: pg_regress.h:26
int i
const char * strerror(int errnum)
Definition: strerror.c:19
static bool nolocale
Definition: pg_regress.c:84
const char * basic_diff_opts
Definition: pg_regress.c:62
static void open_result_files(void)
Definition: pg_regress.c:1867
#define SIGKILL
Definition: win32.h:200
static char * outfile
size_t ai_addrlen
Definition: getaddrinfo.h:106
int ai_flags
Definition: getaddrinfo.h:102
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:222
pg_attribute_unused()
Definition: pg_regress.c:879
static void wait_for_tests(PID_TYPE *pids, int *statuses, char **names, int num_tests)
Definition: pg_regress.c:1480
static char * hostname
Definition: pg_regress.c:86
#define WTERMSIG(w)
Definition: win32.h:183
#define _(x)
Definition: elog.c:84
char * pgport
Definition: pgbench.c:181
long val
Definition: informix.c:689
struct sockaddr * ai_addr
Definition: getaddrinfo.h:107
#define ULONGPID(x)
static void create_database(const char *dbname)
Definition: pg_regress.c:1910
void(* init_function)(int argc, char **argv)
Definition: pg_regress.h:33
int regression_main(int argc, char *argv[], init_function ifunc, test_function tfunc)
Definition: pg_regress.c:2018
int ai_family
Definition: getaddrinfo.h:103