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 #define OPT_DIRECT 1000
  49 #define OPT_TESTDIR 1001
  50
  51 static struct option options[] =
  52 {
  53 #ifdef CMDLINE_OPTIONS
  54   CMDLINE_OPTIONS
  55 #endif
  56   { "direct", no_argument, NULL, OPT_DIRECT },
  57   { "test-dir", required_argument, NULL, OPT_TESTDIR },
  58   { NULL, 0, NULL, 0 }
  59 };
  60
  61 /* PID of the test itself.  */
  62 static pid_t pid;
  63
  64 /* Directory to place temporary files in.  */
  65 static const char *test_dir;
  66
  67 /* List of temporary files.  */
  68 struct temp_name_list
  69 {
  70   struct qelem q;
  71   const char *name;
  72 } *temp_name_list;
  73
  74 /* Add temporary files in list.  */
  75 static void
  76 __attribute__ ((unused))
  77 add_temp_file (const char *name)
  78 {
  79   struct temp_name_list *newp
  80     = (struct temp_name_list *) calloc (sizeof (*newp), 1);
  81   if (newp != NULL)
  82     {
  83       newp->name = name;
  84       if (temp_name_list == NULL)
  85         temp_name_list = (struct temp_name_list *) &newp->q;
  86       else
  87         insque (newp, temp_name_list);
  88     }
  89 }
  90
  91 /* Delete all temporary files.  */
  92 static void
  93 delete_temp_files (void)
  94 {
  95   while (temp_name_list != NULL)
  96     {
  97       remove (temp_name_list->name);
  98       temp_name_list = (struct temp_name_list *) temp_name_list->q.q_forw;
  99     }
 100 }
 101
 102 /* Create a temporary file.  */
 103 static int
 104 __attribute__ ((unused))
 105 create_temp_file (const char *base, char **filename)
 106 {
 107   char *fname;
 108   int fd;
 109
 110   fname = (char *) malloc (strlen (test_dir) + 1 + strlen (base)
 111                            + sizeof ("XXXXXX"));
 112   if (fname == NULL)
 113     {
 114       puts ("out of memory");
 115       return -1;
 116     }
 117   strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
 118
 119   fd = mkstemp (fname);
 120   if (fd == -1)
 121     {
 122       printf ("cannot open temporary file '%s': %m\n", fname);
 123       free (fname);
 124       return -1;
 125     }
 126
 127   add_temp_file (fname);
 128   if (filename != NULL)
 129     *filename = fname;
 130
 131   return fd;
 132 }
 133
 134 /* Timeout handler.  We kill the child and exit with an error.  */
 135 static void
 136 __attribute__ ((noreturn))
 137 signal_handler (int sig __attribute__ ((unused)))
 138 {
 139   int killed;
 140   int status;
 141
 142   assert (pid > 1);
 143   /* Kill the whole process group.  */
 144   kill (-pid, SIGKILL);
 145   /* In case setpgid failed in the child, kill it individually too.  */
 146   kill (pid, SIGKILL);
 147
 148   /* Wait for it to terminate.  */
 149   int i;
 150   for (i = 0; i < 5; ++i)
 151     {
 152       killed = waitpid (pid, &status, WNOHANG|WUNTRACED);
 153       if (killed != 0)
 154         break;
 155
 156       /* Delay, give the system time to process the kill.  If the
 157          nanosleep() call return prematurely, all the better.  We
 158          won't restart it since this probably means the child process
 159          finally died.  */
 160       struct timespec ts;
 161       ts.tv_sec = 0;
 162       ts.tv_nsec = 100000000;
 163       nanosleep (&ts, NULL);
 164     }
 165   if (killed != 0 && killed != pid)
 166     {
 167       printf ("Failed to kill test process: %m\n");
 168       exit (1);
 169     }
 170
 171 #ifdef CLEANUP_HANDLER
 172   CLEANUP_HANDLER;
 173 #endif
 174
 175   if (sig == SIGINT)
 176     {
 177       signal (sig, SIG_DFL);
 178       raise (sig);
 179     }
 180
 181   /* If we expected this signal: good!  */
 182 #ifdef EXPECTED_SIGNAL
 183   if (EXPECTED_SIGNAL == SIGALRM)
 184     exit (0);
 185 #endif
 186
 187   if (killed == 0 || (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL))
 188     puts ("Timed out: killed the child process");
 189   else if (WIFSTOPPED (status))
 190     printf ("Timed out: the child process was %s\n",
 191             strsignal (WSTOPSIG (status)));
 192   else if (WIFSIGNALED (status))
 193     printf ("Timed out: the child process got signal %s\n",
 194             strsignal (WTERMSIG (status)));
 195   else
 196     printf ("Timed out: killed the child process but it exited %d\n",
 197             WEXITSTATUS (status));
 198
 199   /* Exit with an error.  */
 200   exit (1);
 201 }
 202
 203 /* Set fortification error handler.  Used when tests want to verify that bad
 204    code is caught by the library.  */
 205 static void
 206 __attribute__ ((unused))
 207 set_fortify_handler (void (*handler) (int sig))
 208 {
 209   struct sigaction sa;
 210
 211   sa.sa_handler = handler;
 212   sa.sa_flags = 0;
 213   sigemptyset (&sa.sa_mask);
 214
 215   sigaction (SIGABRT, &sa, NULL);
 216
 217   /* Avoid all the buffer overflow messages on stderr.  */
 218   int fd = open (_PATH_DEVNULL, O_WRONLY);
 219   if (fd == -1)
 220     close (STDERR_FILENO);
 221   else
 222     {
 223       dup2 (fd, STDERR_FILENO);
 224       close (fd);
 225     }
 226   setenv ("LIBC_FATAL_STDERR_", "1", 1);
 227 }
 228
 229 /* We provide the entry point here.  */
 230 int
 231 main (int argc, char *argv[])
 232 {
 233   int direct = 0;       /* Directly call the test function?  */
 234   int status;
 235   int opt;
 236   unsigned int timeoutfactor = 1;
 237   pid_t termpid;
 238
 239   /* Make uses of freed and uninitialized memory known.  */
 240   mallopt (M_PERTURB, 42);
 241
 242 #ifdef STDOUT_UNBUFFERED
 243   setbuf (stdout, NULL);
 244 #endif
 245
 246   while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
 247     switch (opt)
 248       {
 249       case '?':
 250         exit (1);
 251       case OPT_DIRECT:
 252         direct = 1;
 253         break;
 254       case OPT_TESTDIR:
 255         test_dir = optarg;
 256         break;
 257 #ifdef CMDLINE_PROCESS
 258         CMDLINE_PROCESS
 259 #endif
 260       }
 261
 262   /* If set, read the test TIMEOUTFACTOR value from the environment.
 263      This value is used to scale the default test timeout values. */
 264   char *envstr_timeoutfactor = getenv ("TIMEOUTFACTOR");
 265   if (envstr_timeoutfactor != NULL)
 266     {
 267       char *envstr_conv = envstr_timeoutfactor;
 268       unsigned long int env_fact;
 269
 270       env_fact = strtoul (envstr_timeoutfactor, &envstr_conv, 0);
 271       if (*envstr_conv == '\0' && envstr_conv != envstr_timeoutfactor)
 272         timeoutfactor = MAX (env_fact, 1);
 273     }
 274
 275   /* Set TMPDIR to specified test directory.  */
 276   if (test_dir != NULL)
 277     {
 278       setenv ("TMPDIR", test_dir, 1);
 279
 280       if (chdir (test_dir) < 0)
 281         {
 282           printf ("chdir: %m\n");
 283           exit (1);
 284         }
 285     }
 286   else
 287     {
 288       test_dir = getenv ("TMPDIR");
 289       if (test_dir == NULL || test_dir[0] == '\0')
 290         test_dir = "/tmp";
 291     }
 292
 293   /* Make sure we see all message, even those on stdout.  */
 294   setvbuf (stdout, NULL, _IONBF, 0);
 295
 296   /* make sure temporary files are deleted.  */
 297   atexit (delete_temp_files);
 298
 299   /* Correct for the possible parameters.  */
 300   argv[optind - 1] = argv[0];
 301   argv += optind - 1;
 302   argc -= optind - 1;
 303
 304   /* Call the initializing function, if one is available.  */
 305 #ifdef PREPARE
 306   PREPARE (argc, argv);
 307 #endif
 308
 309   /* If we are not expected to fork run the function immediately.  */
 310   if (direct)
 311     return TEST_FUNCTION;
 312
 313   /* Set up the test environment:
 314      - prevent core dumps
 315      - set up the timer
 316      - fork and execute the function.  */
 317
 318   pid = fork ();
 319   if (pid == 0)
 320     {
 321       /* This is the child.  */
 322 #ifdef RLIMIT_CORE
 323       /* Try to avoid dumping core.  */
 324       struct rlimit core_limit;
 325       core_limit.rlim_cur = 0;
 326       core_limit.rlim_max = 0;
 327       setrlimit (RLIMIT_CORE, &core_limit);
 328 #endif
 329
 330 #ifdef RLIMIT_DATA
 331       /* Try to avoid eating all memory if a test leaks.  */
 332       struct rlimit data_limit;
 333       if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
 334         {
 335           if (TEST_DATA_LIMIT == RLIM_INFINITY)
 336             data_limit.rlim_cur = data_limit.rlim_max;
 337           else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
 338             data_limit.rlim_cur = MIN ((rlim_t) TEST_DATA_LIMIT,
 339                                        data_limit.rlim_max);
 340           if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
 341             printf ("setrlimit: RLIMIT_DATA: %m\n");
 342         }
 343       else
 344         printf ("getrlimit: RLIMIT_DATA: %m\n");
 345 #endif
 346
 347       /* We put the test process in its own pgrp so that if it bogusly
 348          generates any job control signals, they won't hit the whole build.  */
 349       if (setpgid (0, 0) != 0)
 350         printf ("Failed to set the process group ID: %m\n");
 351
 352       /* Execute the test function and exit with the return value.   */
 353       exit (TEST_FUNCTION);
 354     }
 355   else if (pid < 0)
 356     {
 357       printf ("Cannot fork test program: %m\n");
 358       exit (1);
 359     }
 360
 361   /* Set timeout.  */
 362 #ifndef TIMEOUT
 363   /* Default timeout is two seconds.  */
 364 # define TIMEOUT 2
 365 #endif
 366   signal (SIGALRM, signal_handler);
 367   alarm (TIMEOUT * timeoutfactor);
 368
 369   /* Make sure we clean up if the wrapper gets interrupted.  */
 370   signal (SIGINT, signal_handler);
 371
 372   /* Wait for the regular termination.  */
 373   termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
 374   if (termpid == -1)
 375     {
 376       printf ("Waiting for test program failed: %m\n");
 377       exit (1);
 378     }
 379   if (termpid != pid)
 380     {
 381       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
 382               (long int) pid, (long int) termpid);
 383       exit (1);
 384     }
 385
 386   /* Process terminated normaly without timeout etc.  */
 387   if (WIFEXITED (status))
 388     {
 389 #ifndef EXPECTED_STATUS
 390 # ifndef EXPECTED_SIGNAL
 391       /* Simply exit with the return value of the test.  */
 392       return WEXITSTATUS (status);
 393 # else
 394       printf ("Expected signal '%s' from child, got none\n",
 395               strsignal (EXPECTED_SIGNAL));
 396       exit (1);
 397 # endif
 398 #else
 399       if (WEXITSTATUS (status) != EXPECTED_STATUS)
 400         {
 401           printf ("Expected status %d, got %d\n",
 402                   EXPECTED_STATUS, WEXITSTATUS (status));
 403           exit (1);
 404         }
 405
 406       return 0;
 407 #endif
 408     }
 409   /* Process was killed by timer or other signal.  */
 410   else
 411     {
 412 #ifndef EXPECTED_SIGNAL
 413       printf ("Didn't expect signal from child: got `%s'\n",
 414               strsignal (WTERMSIG (status)));
 415       exit (1);
 416 #else
 417       if (WTERMSIG (status) != EXPECTED_SIGNAL)
 418         {
 419           printf ("Incorrect signal from child: got `%s', need `%s'\n",
 420                   strsignal (WTERMSIG (status)),
 421                   strsignal (EXPECTED_SIGNAL));
 422           exit (1);
 423         }
 424
 425       return 0;
 426 #endif
 427     }
 428 }