1 /* $NetBSD: t_pidfile.c,v 1.3 2011/03/29 13:55:37 jmmv Exp $ */
2
3 /*
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * This file implements tests for the pidfile(3) functions.
31 *
32 * The tests here are tricky because we need to validate that the atexit(3)
33 * handler registered by pidfile(3) correctly deletes the generated pidfile.
34 * To do so:
35 * 1) We spawn a subprocess in every test case,
36 * 2) Run our test code in such subprocesses. We cannot call any of the ATF
37 * primitives from inside these.
38 * 3) Wait for the subprocess to terminate and ensure it exited successfully.
39 * 4) Check that the pidfile(s) created in the subprocess are gone.
40 *
41 * Additionally, pidfile(3) hardcodes a path to a directory writable only by
42 * root (/var/run). This makes us require root privileges to execute these
43 * tests.
44 */
45
46 #include <sys/cdefs.h>
47 __COPYRIGHT("@(#) Copyright (c) 2011\
48 The NetBSD Foundation, inc. All rights reserved.");
49 __RCSID("$NetBSD: t_pidfile.c,v 1.3 2011/03/29 13:55:37 jmmv Exp $");
50
51 #include <sys/stat.h>
52 #include <sys/wait.h>
53
54 #include <assert.h>
55 #include <err.h>
56 #include <stdbool.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <paths.h>
60 #include <unistd.h>
61 #include <util.h>
62
63 #include <atf-c.h>
64
65 /* Used by routines that can be called both from the parent and the child
66 * code to implement proper error reporting. */
67 static bool in_child = false;
68
69 /* Callable from the test case child code. */
70 static void
check_pidfile(const char * path)71 check_pidfile(const char *path)
72 {
73 FILE *file;
74 int pid;
75
76 printf("Validating contents of pidfile '%s'\n", path);
77
78 if ((file = fopen(path, "r")) == NULL)
79 errx(EXIT_FAILURE, "Cannot open expected pidfile '%s'", path);
80
81 if (fscanf(file, "%d", &pid) == -1)
82 errx(EXIT_FAILURE, "Failed to read pid from pidfile '%s'",
83 path);
84
85 printf("Read pid %d, current pid %d\n", pid, getpid());
86 if (pid != getpid())
87 errx(EXIT_FAILURE, "Pid in pidfile (%d) does not match "
88 "current pid (%d)", pid, getpid());
89 }
90
91 /* Callable from the test case parent/child code. */
92 static void
ensure_deleted(const char * path)93 ensure_deleted(const char *path)
94 {
95 printf("Ensuring pidfile %s does not exist any more\n", path);
96 if (access(path, R_OK) != -1) {
97 unlink(path);
98 if (in_child)
99 errx(EXIT_FAILURE, "The pidfile %s was not deleted",
100 path);
101 else
102 atf_tc_fail("The pidfile %s was not deleted", path);
103 }
104 }
105
106 /* Callable from the test case parent code. */
107 static void
run_child(void (* child)(const char *),const char * cookie)108 run_child(void (*child)(const char *), const char *cookie)
109 {
110 pid_t pid;
111
112 pid = fork();
113 ATF_REQUIRE(pid != -1);
114 if (pid == 0) {
115 in_child = true;
116 child(cookie);
117 assert(false);
118 /* UNREACHABLE */
119 } else {
120 int status;
121
122 ATF_REQUIRE(waitpid(pid, &status, 0) != -1);
123 if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS)
124 atf_tc_fail("See stderr for details");
125 }
126 }
127
128 /* Callable from the test case parent/child code. */
129 static char *
generate_varrun_pidfile(const char * basename)130 generate_varrun_pidfile(const char *basename)
131 {
132 char *path;
133
134 if (asprintf(&path, "%s%s.pid", _PATH_VARRUN,
135 basename == NULL ? getprogname() : basename) == -1) {
136 if (in_child)
137 errx(EXIT_FAILURE, "Cannot allocate memory for path");
138 else
139 atf_tc_fail("Cannot allocate memory for path");
140 }
141
142 return path;
143 }
144
145 static void
helper_default_path(const char * path)146 helper_default_path(const char *path)
147 {
148
149 if (pidfile(NULL) == -1)
150 errx(EXIT_FAILURE, "Failed to create pidfile with default "
151 "basename");
152
153 check_pidfile(path);
154 exit(EXIT_SUCCESS);
155 }
156
157 ATF_TC(default_path);
ATF_TC_HEAD(default_path,tc)158 ATF_TC_HEAD(default_path, tc)
159 {
160 atf_tc_set_md_var(tc, "require.user", "root");
161 }
ATF_TC_BODY(default_path,tc)162 ATF_TC_BODY(default_path, tc)
163 {
164 char *path;
165
166 path = generate_varrun_pidfile(NULL);
167 run_child(helper_default_path, path);
168 ensure_deleted(path);
169 free(path);
170 }
171
172 static void
helper_custom_basename(const char * path)173 helper_custom_basename(const char *path)
174 {
175
176 if (pidfile("custom-basename") == -1)
177 errx(EXIT_FAILURE, "Failed to create pidfile with custom "
178 "basename");
179
180 check_pidfile(path);
181 exit(EXIT_SUCCESS);
182 }
183
184 ATF_TC(custom_basename);
ATF_TC_HEAD(custom_basename,tc)185 ATF_TC_HEAD(custom_basename, tc)
186 {
187 atf_tc_set_md_var(tc, "require.user", "root");
188 }
ATF_TC_BODY(custom_basename,tc)189 ATF_TC_BODY(custom_basename, tc)
190 {
191 char *path;
192
193 path = generate_varrun_pidfile("custom-basename");
194 run_child(helper_custom_basename, path);
195 ensure_deleted(path);
196 free(path);
197 }
198
199 static void
helper_custom_path(const char * path)200 helper_custom_path(const char *path)
201 {
202
203 if (pidfile(path) == -1)
204 errx(EXIT_FAILURE, "Failed to create pidfile '%s'", path);
205 check_pidfile(path);
206 exit(EXIT_SUCCESS);
207 }
208
209 ATF_TC_WITHOUT_HEAD(custom_path);
ATF_TC_BODY(custom_path,tc)210 ATF_TC_BODY(custom_path, tc)
211 {
212
213 ATF_REQUIRE(mkdir("var", 0777) != -1);
214 ATF_REQUIRE(mkdir("var/run", 0777) != -1);
215
216 run_child(helper_custom_path, "./var/run/my-pidfile.pid");
217
218 ensure_deleted("./var/run/my-pidfile.pid");
219 }
220
221 static void
helper_change_basenames(const char * unused_cookie)222 helper_change_basenames(const char *unused_cookie)
223 {
224 char *default_path;
225 char *custom_path;
226
227 default_path = generate_varrun_pidfile(NULL);
228 if (pidfile(NULL) == -1)
229 errx(EXIT_FAILURE, "Failed to create pidfile with default "
230 "basename");
231 check_pidfile(default_path);
232 if (pidfile(NULL) == -1)
233 errx(EXIT_FAILURE, "Failed to recreate pidfile with default "
234 "basename");
235 check_pidfile(default_path);
236
237 custom_path = generate_varrun_pidfile("custom-basename");
238 if (pidfile("custom-basename") == -1)
239 errx(EXIT_FAILURE, "Failed to create pidfile with custom "
240 "basename");
241 ensure_deleted(default_path);
242 check_pidfile(custom_path);
243 if (pidfile("custom-basename") == -1)
244 errx(EXIT_FAILURE, "Failed to recreate pidfile with custom "
245 "basename");
246 check_pidfile(custom_path);
247
248 free(custom_path);
249 free(default_path);
250 exit(EXIT_SUCCESS);
251 }
252
253 ATF_TC(change_basenames);
ATF_TC_HEAD(change_basenames,tc)254 ATF_TC_HEAD(change_basenames, tc)
255 {
256 atf_tc_set_md_var(tc, "require.user", "root");
257 }
ATF_TC_BODY(change_basenames,tc)258 ATF_TC_BODY(change_basenames, tc)
259 {
260 char *default_path;
261 char *custom_path;
262
263 run_child(helper_change_basenames, NULL);
264
265 default_path = generate_varrun_pidfile(NULL);
266 custom_path = generate_varrun_pidfile("custom-basename");
267
268 ensure_deleted(default_path);
269 ensure_deleted(custom_path);
270
271 free(custom_path);
272 free(default_path);
273 }
274
275 static void
helper_change_paths(const char * unused_cookie)276 helper_change_paths(const char *unused_cookie)
277 {
278
279 if (pidfile("./var/run/first.pid") == -1)
280 errx(EXIT_FAILURE, "Failed to create pidfile "
281 "'./var/run/first.pid'");
282 check_pidfile("./var/run/first.pid");
283
284 if (pidfile("./second.pid") == -1)
285 errx(EXIT_FAILURE, "Failed to create pidfile 'second.pid'");
286 ensure_deleted("./var/run/first.pid");
287 check_pidfile("./second.pid");
288
289 exit(EXIT_SUCCESS);
290 }
291
292 ATF_TC_WITHOUT_HEAD(change_paths);
ATF_TC_BODY(change_paths,tc)293 ATF_TC_BODY(change_paths, tc)
294 {
295
296 ATF_REQUIRE(mkdir("var", 0777) != -1);
297 ATF_REQUIRE(mkdir("var/run", 0777) != -1);
298
299 run_child(helper_change_paths, NULL);
300
301 ensure_deleted("./var/run/my-pidfile.pid");
302 ensure_deleted("second.pid");
303 }
304
305 static void
helper_mix(const char * unused_cookie)306 helper_mix(const char *unused_cookie)
307 {
308 char *default_path;
309 char *custom_path;
310
311 default_path = generate_varrun_pidfile(NULL);
312 custom_path = generate_varrun_pidfile("custom-basename");
313
314 if (pidfile(NULL) == -1)
315 errx(EXIT_FAILURE, "Failed to create default pidfile");
316 check_pidfile(default_path);
317
318 if (pidfile("./second.pid") == -1)
319 errx(EXIT_FAILURE, "Failed to create pidfile 'second.pid'");
320 ensure_deleted(default_path);
321 check_pidfile("./second.pid");
322
323 if (pidfile("custom-basename") == -1)
324 errx(EXIT_FAILURE, "Failed to create pidfile 'second.pid'");
325 ensure_deleted(default_path);
326 ensure_deleted("./second.pid");
327 ensure_deleted("./custom-basename");
328 check_pidfile(custom_path);
329
330 free(custom_path);
331 free(default_path);
332 exit(EXIT_SUCCESS);
333 }
334
335 ATF_TC(change_mix);
ATF_TC_HEAD(change_mix,tc)336 ATF_TC_HEAD(change_mix, tc)
337 {
338 atf_tc_set_md_var(tc, "require.user", "root");
339 }
ATF_TC_BODY(change_mix,tc)340 ATF_TC_BODY(change_mix, tc)
341 {
342 char *default_path;
343
344 run_child(helper_mix, NULL);
345
346 default_path = generate_varrun_pidfile(NULL);
347 ensure_deleted(default_path);
348 ensure_deleted("second.pid");
349 free(default_path);
350 }
351
ATF_TP_ADD_TCS(tp)352 ATF_TP_ADD_TCS(tp)
353 {
354
355 ATF_TP_ADD_TC(tp, default_path);
356 ATF_TP_ADD_TC(tp, custom_basename);
357 ATF_TP_ADD_TC(tp, custom_path);
358 ATF_TP_ADD_TC(tp, change_basenames);
359 ATF_TP_ADD_TC(tp, change_paths);
360 ATF_TP_ADD_TC(tp, change_mix);
361
362 return atf_no_error();
363 }
364