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 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 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 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 * 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 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); 158 ATF_TC_HEAD(default_path, tc) 159 { 160 atf_tc_set_md_var(tc, "require.user", "root"); 161 } 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 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); 185 ATF_TC_HEAD(custom_basename, tc) 186 { 187 atf_tc_set_md_var(tc, "require.user", "root"); 188 } 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 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); 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 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); 254 ATF_TC_HEAD(change_basenames, tc) 255 { 256 atf_tc_set_md_var(tc, "require.user", "root"); 257 } 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 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); 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 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); 336 ATF_TC_HEAD(change_mix, tc) 337 { 338 atf_tc_set_md_var(tc, "require.user", "root"); 339 } 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 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