Include <errno.h>.
[kopensolaris-gnu/glibc.git] / test-skeleton.c
1 /* Skeleton for test programs.
2    Copyright (C) 1998, 2000, 2001, 2002, 2003 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, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <errno.h>
22 #include <getopt.h>
23 #include <search.h>
24 #include <signal.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/resource.h>
30 #include <sys/wait.h>
31 #include <sys/param.h>
32
33 /* The test function is normally called `do_test' and it is called
34    with argc and argv as the arguments.  We nevertheless provide the
35    possibility to overwrite this name.  */
36 #ifndef TEST_FUNCTION
37 # define TEST_FUNCTION do_test (argc, argv)
38 #endif
39
40 #ifndef TEST_DATA_LIMIT
41 # define TEST_DATA_LIMIT (64 << 20) /* Data limit (bytes) to run with.  */
42 #endif
43
44 #define OPT_DIRECT 1000
45 #define OPT_TESTDIR 1001
46
47 static struct option options[] =
48 {
49 #ifdef CMDLINE_OPTIONS
50   CMDLINE_OPTIONS
51 #endif
52   { "direct", no_argument, NULL, OPT_DIRECT },
53   { "test-dir", required_argument, NULL, OPT_TESTDIR },
54   { NULL, 0, NULL, 0 }
55 };
56
57 /* PID of the test itself.  */
58 static pid_t pid;
59
60 /* Directory to place temporary files in.  */
61 static const char *test_dir;
62
63 /* List of temporary files.  */
64 struct temp_name_list
65 {
66   struct qelem q;
67   const char *name;
68 } *temp_name_list;
69
70 /* Add temporary files in list.  */
71 static void
72 __attribute__ ((unused))
73 add_temp_file (const char *name)
74 {
75   struct temp_name_list *newp
76     = (struct temp_name_list *) calloc (sizeof (*newp), 1);
77   if (newp != NULL)
78     {
79       newp->name = name;
80       if (temp_name_list == NULL)
81         temp_name_list = (struct temp_name_list *) &newp->q;
82       else
83         insque (newp, temp_name_list);
84     }
85 }
86
87 /* Delete all temporary files.  */
88 static void
89 delete_temp_files (void)
90 {
91   while (temp_name_list != NULL)
92     {
93       remove (temp_name_list->name);
94       temp_name_list = (struct temp_name_list *) temp_name_list->q.q_forw;
95     }
96 }
97
98 /* Create a temporary file.  */
99 static int
100 __attribute__ ((unused))
101 create_temp_file (const char *base, char **filename)
102 {
103   char *fname;
104   int fd;
105
106   fname = (char *) malloc (strlen (test_dir) + 1 + strlen (base)
107                            + sizeof ("XXXXXX"));
108   if (fname == NULL)
109     {
110       puts ("out of memory");
111       return -1;
112     }
113   strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
114
115   fd = mkstemp (fname);
116   if (fd == -1)
117     {
118       printf ("cannot open temporary file '%s': %m\n", fname);
119       free (fname);
120       return -1;
121     }
122
123   add_temp_file (fname);
124   if (filename != NULL)
125     *filename = fname;
126
127   return fd;
128 }
129
130 /* Timeout handler.  We kill the child and exit with an error.  */
131 static void
132 __attribute__ ((noreturn))
133 timeout_handler (int sig __attribute__ ((unused)))
134 {
135   int killed;
136   int status;
137
138   /* Send signal.  */
139   kill (pid, SIGKILL);
140
141   /* Wait for it to terminate.  */
142   killed = waitpid (pid, &status, WNOHANG|WUNTRACED);
143   if (killed != 0 && killed != pid)
144     {
145       perror ("Failed to killed test process");
146       exit (1);
147     }
148
149 #ifdef CLEANUP_HANDLER
150   CLEANUP_HANDLER;
151 #endif
152
153   /* If we expected this signal: good!  */
154 #ifdef EXPECTED_SIGNAL
155   if (EXPECTED_SIGNAL == SIGALRM)
156     exit (0);
157 #endif
158
159   if (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL)
160     fputs ("Timed out: killed the child process\n", stderr);
161   else if (WIFSTOPPED (status))
162     fprintf (stderr, "Timed out: the child process was %s\n",
163              strsignal (WSTOPSIG (status)));
164   else if (WIFSIGNALED (status))
165     fprintf (stderr, "Timed out: the child process got signal %s\n",
166              strsignal (WTERMSIG (status)));
167   else
168     fprintf (stderr, "Timed out: killed the child process but it exited %d\n",
169              WEXITSTATUS (status));
170
171   /* Exit with an error.  */
172   exit (1);
173 }
174
175 /* We provide the entry point here.  */
176 int
177 main (int argc, char *argv[])
178 {
179   int direct = 0;       /* Directly call the test function?  */
180   int status;
181   int opt;
182   pid_t termpid;
183
184 #ifdef STDOUT_UNBUFFERED
185   setbuf (stdout, NULL);
186 #endif
187
188   while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
189     switch (opt)
190       {
191       case '?':
192         exit (1);
193       case OPT_DIRECT:
194         direct = 1;
195         break;
196       case OPT_TESTDIR:
197         test_dir = optarg;
198         break;
199 #ifdef CMDLINE_PROCESS
200         CMDLINE_PROCESS
201 #endif
202       }
203
204   /* Set TMPDIR to specified test directory.  */
205   if (test_dir != NULL)
206     {
207       setenv ("TMPDIR", test_dir, 1);
208
209       if (chdir (test_dir) < 0)
210         {
211           perror ("chdir");
212           exit (1);
213         }
214     }
215   else
216     {
217       test_dir = getenv ("TMPDIR");
218       if (test_dir == NULL || test_dir[0] == '\0')
219         test_dir = "/tmp";
220     }
221
222   /* Make sure we see all message, even those on stdout.  */
223   setvbuf (stdout, NULL, _IONBF, 0);
224
225   /* make sure temporary files are deleted.  */
226   atexit (delete_temp_files);
227
228   /* Correct for the possible parameters.  */
229   argv[optind - 1] = argv[0];
230   argv += optind - 1;
231   argc -= optind - 1;
232
233   /* Call the initializing function, if one is available.  */
234 #ifdef PREPARE
235   PREPARE (argc, argv);
236 #endif
237
238   /* If we are not expected to fork run the function immediately.  */
239   if (direct)
240     return TEST_FUNCTION;
241
242   /* Set up the test environment:
243      - prevent core dumps
244      - set up the timer
245      - fork and execute the function.  */
246
247   pid = fork ();
248   if (pid == 0)
249     {
250       /* This is the child.  */
251 #ifdef RLIMIT_CORE
252       /* Try to avoid dumping core.  */
253       struct rlimit core_limit;
254       core_limit.rlim_cur = 0;
255       core_limit.rlim_max = 0;
256       setrlimit (RLIMIT_CORE, &core_limit);
257 #endif
258
259 #ifdef RLIMIT_DATA
260       /* Try to avoid eating all memory if a test leaks.  */
261       struct rlimit data_limit;
262       if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
263         {
264           if (TEST_DATA_LIMIT == RLIM_INFINITY)
265             data_limit.rlim_cur = data_limit.rlim_max;
266           else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
267             data_limit.rlim_cur = MIN ((rlim_t) TEST_DATA_LIMIT,
268                                        data_limit.rlim_max);
269           if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
270             perror ("setrlimit: RLIMIT_DATA");
271         }
272       else
273         perror ("getrlimit: RLIMIT_DATA");
274 #endif
275
276       /* We put the test process in its own pgrp so that if it bogusly
277          generates any job control signals, they won't hit the whole build.  */
278       setpgid (0, 0);
279
280       /* Execute the test function and exit with the return value.   */
281       exit (TEST_FUNCTION);
282     }
283   else if (pid < 0)
284     {
285       perror ("Cannot fork test program");
286       exit (1);
287     }
288
289   /* Set timeout.  */
290 #ifndef TIMEOUT
291   /* Default timeout is two seconds.  */
292 # define TIMEOUT 2
293 #endif
294   signal (SIGALRM, timeout_handler);
295   alarm (TIMEOUT);
296
297   /* Wait for the regular termination.  */
298   termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
299   if (termpid == -1)
300     {
301       printf ("Waiting for test program failed: %m\n");
302       exit (1);
303     }
304   if (termpid != pid)
305     {
306       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
307               (long int) pid, (long int) termpid);
308       exit (1);
309     }
310
311 #ifndef EXPECTED_SIGNAL
312   /* We don't expect any signal.  */
313 # define EXPECTED_SIGNAL 0
314 #endif
315   if (WTERMSIG (status) != EXPECTED_SIGNAL)
316     {
317       if (EXPECTED_SIGNAL != 0)
318         {
319           if (WTERMSIG (status) == 0)
320             fprintf (stderr,
321                      "Expected signal '%s' from child, got none\n",
322                      strsignal (EXPECTED_SIGNAL));
323           else
324             fprintf (stderr,
325                      "Incorrect signal from child: got `%s', need `%s'\n",
326                      strsignal (WTERMSIG (status)),
327                      strsignal (EXPECTED_SIGNAL));
328         }
329       else
330         fprintf (stderr, "Didn't expect signal from child: got `%s'\n",
331                  strsignal (WTERMSIG (status)));
332       exit (1);
333     }
334
335   /* Simply exit with the return value of the test.  */
336   return WEXITSTATUS (status);
337 }