test-skeleton.c

   1 /* Skeleton for test programs.
   2    Copyright (C) 1998-2015 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <getopt.h>
  24 #include <malloc.h>
  25 #include <paths.h>
  26 #include <search.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <sys/resource.h>
  33 #include <sys/wait.h>
  34 #include <sys/param.h>
  35 #include <time.h>
  36
  37 /* The test function is normally called `do_test' and it is called
  38    with argc and argv as the arguments.  We nevertheless provide the
  39    possibility to overwrite this name.  */
  40 #ifndef TEST_FUNCTION
  41 # define TEST_FUNCTION do_test (argc, argv)
  42 #endif
  43
  44 #ifndef TEST_DATA_LIMIT
  45 # define TEST_DATA_LIMIT (64 << 20) /* Data limit (bytes) to run with.  */
  46 #endif
  47
  48 #ifndef TIMEOUT
  49   /* Default timeout is two seconds.  */
  50 # define TIMEOUT 2
  51 #endif
  52
  53 #define OPT_DIRECT 1000
  54 #define OPT_TESTDIR 1001
  55
  56 static struct option options[] =
  57 {
  58 #ifdef CMDLINE_OPTIONS
  59   CMDLINE_OPTIONS
  60 #endif
  61   { "direct", no_argument, NULL, OPT_DIRECT },
  62   { "test-dir", required_argument, NULL, OPT_TESTDIR },
  63   { NULL, 0, NULL, 0 }
  64 };
  65
  66 /* PID of the test itself.  */
  67 static pid_t pid;
  68
  69 /* Directory to place temporary files in.  */
  70 static const char *test_dir;
  71
  72 /* List of temporary files.  */
  73 struct temp_name_list
  74 {
  75   struct qelem q;
  76   char *name;
  77 } *temp_name_list;
  78
  79 /* Add temporary files in list.  */
  80 static void
  81 __attribute__ ((unused))
  82 add_temp_file (const char *name)
  83 {
  84   struct temp_name_list *newp
  85     = (struct temp_name_list *) calloc (sizeof (*newp), 1);
  86   char *newname = strdup (name);
  87   if (newp != NULL && newname != NULL)
  88     {
  89       newp->name = newname;
  90       if (temp_name_list == NULL)
  91         temp_name_list = (struct temp_name_list *) &newp->q;
  92       else
  93         insque (newp, temp_name_list);
  94     }
  95   else
  96     free (newp);
  97 }
  98
  99 /* Delete all temporary files.  */
 100 static void
 101 delete_temp_files (void)
 102 {
 103   while (temp_name_list != NULL)
 104     {
 105       remove (temp_name_list->name);
 106       free (temp_name_list->name);
 107
 108       struct temp_name_list *next
 109         = (struct temp_name_list *) temp_name_list->q.q_forw;
 110       free (temp_name_list);
 111       temp_name_list = next;
 112     }
 113 }
 114
 115 /* Create a temporary file.  Return the opened file descriptor on
 116    success, or -1 on failure.  Write the file name to *FILENAME if
 117    FILENAME is not NULL.  In this case, the caller is expected to free
 118    *FILENAME.  */
 119 static int
 120 __attribute__ ((unused))
 121 create_temp_file (const char *base, char **filename)
 122 {
 123   char *fname;
 124   int fd;
 125
 126   fname = (char *) malloc (strlen (test_dir) + 1 + strlen (base)
 127                            + sizeof ("XXXXXX"));
 128   if (fname == NULL)
 129     {
 130       puts ("out of memory");
 131       return -1;
 132     }
 133   strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
 134
 135   fd = mkstemp (fname);
 136   if (fd == -1)
 137     {
 138       printf ("cannot open temporary file '%s': %m\n", fname);
 139       free (fname);
 140       return -1;
 141     }
 142
 143   add_temp_file (fname);
 144   if (filename != NULL)
 145     *filename = fname;
 146   else
 147     free (fname);
 148
 149   return fd;
 150 }
 151
 152 /* Timeout handler.  We kill the child and exit with an error.  */
 153 static void
 154 __attribute__ ((noreturn))
 155 signal_handler (int sig __attribute__ ((unused)))
 156 {
 157   int killed;
 158   int status;
 159
 160   assert (pid > 1);
 161   /* Kill the whole process group.  */
 162   kill (-pid, SIGKILL);
 163   /* In case setpgid failed in the child, kill it individually too.  */
 164   kill (pid, SIGKILL);
 165
 166   /* Wait for it to terminate.  */
 167   int i;
 168   for (i = 0; i < 5; ++i)
 169     {
 170       killed = waitpid (pid, &status, WNOHANG|WUNTRACED);
 171       if (killed != 0)
 172         break;
 173
 174       /* Delay, give the system time to process the kill.  If the
 175          nanosleep() call return prematurely, all the better.  We
 176          won't restart it since this probably means the child process
 177          finally died.  */
 178       struct timespec ts;
 179       ts.tv_sec = 0;
 180       ts.tv_nsec = 100000000;
 181       nanosleep (&ts, NULL);
 182     }
 183   if (killed != 0 && killed != pid)
 184     {
 185       printf ("Failed to kill test process: %m\n");
 186       exit (1);
 187     }
 188
 189 #ifdef CLEANUP_HANDLER
 190   CLEANUP_HANDLER;
 191 #endif
 192
 193   if (sig == SIGINT)
 194     {
 195       signal (sig, SIG_DFL);
 196       raise (sig);
 197     }
 198
 199   /* If we expected this signal: good!  */
 200 #ifdef EXPECTED_SIGNAL
 201   if (EXPECTED_SIGNAL == SIGALRM)
 202     exit (0);
 203 #endif
 204
 205   if (killed == 0 || (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL))
 206     puts ("Timed out: killed the child process");
 207   else if (WIFSTOPPED (status))
 208     printf ("Timed out: the child process was %s\n",
 209             strsignal (WSTOPSIG (status)));
 210   else if (WIFSIGNALED (status))
 211     printf ("Timed out: the child process got signal %s\n",
 212             strsignal (WTERMSIG (status)));
 213   else
 214     printf ("Timed out: killed the child process but it exited %d\n",
 215             WEXITSTATUS (status));
 216
 217   /* Exit with an error.  */
 218   exit (1);
 219 }
 220
 221 /* Avoid all the buffer overflow messages on stderr.  */
 222 static void
 223 __attribute__ ((unused))
 224 ignore_stderr (void)
 225 {
 226   int fd = open (_PATH_DEVNULL, O_WRONLY);
 227   if (fd == -1)
 228     close (STDERR_FILENO);
 229   else
 230     {
 231       dup2 (fd, STDERR_FILENO);
 232       close (fd);
 233     }
 234   setenv ("LIBC_FATAL_STDERR_", "1", 1);
 235 }
 236
 237 /* Set fortification error handler.  Used when tests want to verify that bad
 238    code is caught by the library.  */
 239 static void
 240 __attribute__ ((unused))
 241 set_fortify_handler (void (*handler) (int sig))
 242 {
 243   struct sigaction sa;
 244
 245   sa.sa_handler = handler;
 246   sa.sa_flags = 0;
 247   sigemptyset (&sa.sa_mask);
 248
 249   sigaction (SIGABRT, &sa, NULL);
 250   ignore_stderr ();
 251 }
 252
 253 /* Show people how to run the program.  */
 254 static void
 255 usage (void)
 256 {
 257   size_t i;
 258
 259   printf ("Usage: %s [options]\n"
 260           "\n"
 261           "Environment Variables:\n"
 262           "  TIMEOUTFACTOR          An integer used to scale the timeout\n"
 263           "  TMPDIR                 Where to place temporary files\n"
 264           "\n",
 265           program_invocation_short_name);
 266   printf ("Options:\n");
 267   for (i = 0; options[i].name; ++i)
 268     {
 269       int indent;
 270
 271       indent = printf ("  --%s", options[i].name);
 272       if (options[i].has_arg == required_argument)
 273         indent += printf (" <arg>");
 274       printf ("%*s", 25 - indent, "");
 275       switch (options[i].val)
 276         {
 277         case OPT_DIRECT:
 278           printf ("Run the test directly (instead of forking & monitoring)");
 279           break;
 280         case OPT_TESTDIR:
 281           printf ("Override the TMPDIR env var");
 282           break;
 283         }
 284       printf ("\n");
 285     }
 286 }
 287
 288 /* We provide the entry point here.  */
 289 int
 290 main (int argc, char *argv[])
 291 {
 292   int direct = 0;       /* Directly call the test function?  */
 293   int status;
 294   int opt;
 295   unsigned int timeoutfactor = 1;
 296   pid_t termpid;
 297
 298   /* Make uses of freed and uninitialized memory known.  */
 299   mallopt (M_PERTURB, 42);
 300
 301 #ifdef STDOUT_UNBUFFERED
 302   setbuf (stdout, NULL);
 303 #endif
 304
 305   while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
 306     switch (opt)
 307       {
 308       case '?':
 309         usage ();
 310         exit (1);
 311       case OPT_DIRECT:
 312         direct = 1;
 313         break;
 314       case OPT_TESTDIR:
 315         test_dir = optarg;
 316         break;
 317 #ifdef CMDLINE_PROCESS
 318         CMDLINE_PROCESS
 319 #endif
 320       }
 321
 322   /* If set, read the test TIMEOUTFACTOR value from the environment.
 323      This value is used to scale the default test timeout values. */
 324   char *envstr_timeoutfactor = getenv ("TIMEOUTFACTOR");
 325   if (envstr_timeoutfactor != NULL)
 326     {
 327       char *envstr_conv = envstr_timeoutfactor;
 328       unsigned long int env_fact;
 329
 330       env_fact = strtoul (envstr_timeoutfactor, &envstr_conv, 0);
 331       if (*envstr_conv == '\0' && envstr_conv != envstr_timeoutfactor)
 332         timeoutfactor = MAX (env_fact, 1);
 333     }
 334
 335   /* Set TMPDIR to specified test directory.  */
 336   if (test_dir != NULL)
 337     {
 338       setenv ("TMPDIR", test_dir, 1);
 339
 340       if (chdir (test_dir) < 0)
 341         {
 342           printf ("chdir: %m\n");
 343           exit (1);
 344         }
 345     }
 346   else
 347     {
 348       test_dir = getenv ("TMPDIR");
 349       if (test_dir == NULL || test_dir[0] == '\0')
 350         test_dir = "/tmp";
 351     }
 352
 353   /* Make sure we see all message, even those on stdout.  */
 354   setvbuf (stdout, NULL, _IONBF, 0);
 355
 356   /* Make sure temporary files are deleted.  */
 357   atexit (delete_temp_files);
 358
 359   /* Correct for the possible parameters.  */
 360   argv[optind - 1] = argv[0];
 361   argv += optind - 1;
 362   argc -= optind - 1;
 363
 364   /* Call the initializing function, if one is available.  */
 365 #ifdef PREPARE
 366   PREPARE (argc, argv);
 367 #endif
 368
 369   const char *envstr_direct = getenv ("TEST_DIRECT");
 370   if (envstr_direct != NULL)
 371     {
 372       FILE *f = fopen (envstr_direct, "w");
 373       if (f == NULL)
 374         {
 375           printf ("cannot open TEST_DIRECT output file '%s': %m\n",
 376                   envstr_direct);
 377           exit (1);
 378         }
 379
 380       fprintf (f, "timeout=%u\ntimeoutfactor=%u\n", TIMEOUT, timeoutfactor);
 381 #ifdef EXPECTED_STATUS
 382       fprintf (f, "exit=%u\n", EXPECTED_STATUS);
 383 #endif
 384 #ifdef EXPECTED_SIGNAL
 385       switch (EXPECTED_SIGNAL)
 386         {
 387         default: abort ();
 388 # define init_sig(signo, name, text) \
 389         case signo: fprintf (f, "signal=%s\n", name); break;
 390 # include <siglist.h>
 391 # undef init_sig
 392         }
 393 #endif
 394
 395       if (temp_name_list != NULL)
 396         {
 397           struct temp_name_list *n;
 398           fprintf (f, "temp_files=(\n");
 399           for (n = temp_name_list;
 400                n != NULL;
 401                n = (struct temp_name_list *) n->q.q_forw)
 402             fprintf (f, "  '%s'\n", n->name);
 403           fprintf (f, ")\n");
 404         }
 405
 406       fclose (f);
 407       direct = 1;
 408     }
 409
 410   /* If we are not expected to fork run the function immediately.  */
 411   if (direct)
 412     return TEST_FUNCTION;
 413
 414   /* Set up the test environment:
 415      - prevent core dumps
 416      - set up the timer
 417      - fork and execute the function.  */
 418
 419   pid = fork ();
 420   if (pid == 0)
 421     {
 422       /* This is the child.  */
 423 #ifdef RLIMIT_CORE
 424       /* Try to avoid dumping core.  */
 425       struct rlimit core_limit;
 426       core_limit.rlim_cur = 0;
 427       core_limit.rlim_max = 0;
 428       setrlimit (RLIMIT_CORE, &core_limit);
 429 #endif
 430
 431 #ifdef RLIMIT_DATA
 432       /* Try to avoid eating all memory if a test leaks.  */
 433       struct rlimit data_limit;
 434       if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
 435         {
 436           if (TEST_DATA_LIMIT == RLIM_INFINITY)
 437             data_limit.rlim_cur = data_limit.rlim_max;
 438           else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
 439             data_limit.rlim_cur = MIN ((rlim_t) TEST_DATA_LIMIT,
 440                                        data_limit.rlim_max);
 441           if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
 442             printf ("setrlimit: RLIMIT_DATA: %m\n");
 443         }
 444       else
 445         printf ("getrlimit: RLIMIT_DATA: %m\n");
 446 #endif
 447
 448       /* We put the test process in its own pgrp so that if it bogusly
 449          generates any job control signals, they won't hit the whole build.  */
 450       if (setpgid (0, 0) != 0)
 451         printf ("Failed to set the process group ID: %m\n");
 452
 453       /* Execute the test function and exit with the return value.   */
 454       exit (TEST_FUNCTION);
 455     }
 456   else if (pid < 0)
 457     {
 458       printf ("Cannot fork test program: %m\n");
 459       exit (1);
 460     }
 461
 462   /* Set timeout.  */
 463   signal (SIGALRM, signal_handler);
 464   alarm (TIMEOUT * timeoutfactor);
 465
 466   /* Make sure we clean up if the wrapper gets interrupted.  */
 467   signal (SIGINT, signal_handler);
 468
 469   /* Wait for the regular termination.  */
 470   termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
 471   if (termpid == -1)
 472     {
 473       printf ("Waiting for test program failed: %m\n");
 474       exit (1);
 475     }
 476   if (termpid != pid)
 477     {
 478       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
 479               (long int) pid, (long int) termpid);
 480       exit (1);
 481     }
 482
 483   /* Process terminated normaly without timeout etc.  */
 484   if (WIFEXITED (status))
 485     {
 486 #ifndef EXPECTED_STATUS
 487 # ifndef EXPECTED_SIGNAL
 488       /* Simply exit with the return value of the test.  */
 489       return WEXITSTATUS (status);
 490 # else
 491       printf ("Expected signal '%s' from child, got none\n",
 492               strsignal (EXPECTED_SIGNAL));
 493       exit (1);
 494 # endif
 495 #else
 496       if (WEXITSTATUS (status) != EXPECTED_STATUS)
 497         {
 498           printf ("Expected status %d, got %d\n",
 499                   EXPECTED_STATUS, WEXITSTATUS (status));
 500           exit (1);
 501         }
 502
 503       return 0;
 504 #endif
 505     }
 506   /* Process was killed by timer or other signal.  */
 507   else
 508     {
 509 #ifndef EXPECTED_SIGNAL
 510       printf ("Didn't expect signal from child: got `%s'\n",
 511               strsignal (WTERMSIG (status)));
 512       exit (1);
 513 #else
 514       if (WTERMSIG (status) != EXPECTED_SIGNAL)
 515         {
 516           printf ("Incorrect signal from child: got `%s', need `%s'\n",
 517                   strsignal (WTERMSIG (status)),
 518                   strsignal (EXPECTED_SIGNAL));
 519           exit (1);
 520         }
 521
 522       return 0;
 523 #endif
 524     }
 525 }