contrib/netbsd-tests/lib/libc/gen/posix_spawn/t_fileactions.c

   1 /* $NetBSD: t_fileactions.c,v 1.5 2012/04/09 19:42:07 martin Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2012 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Charles Zhang <charles@NetBSD.org> and
   9  * Martin Husemann <martin@NetBSD.org>.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33
  34 #ifdef __FreeBSD__
  35 #include <sys/stat.h>
  36 #endif
  37 #include <atf-c.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <spawn.h>
  44 #include <unistd.h>
  45 #include <sys/wait.h>
  46
  47
  48 ATF_TC(t_spawn_openmode);
  49
  50 ATF_TC_HEAD(t_spawn_openmode, tc)
  51 {
  52         atf_tc_set_md_var(tc, "descr",
  53             "Test the proper handling of 'mode' for 'open' fileactions");
  54         atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
  55 }
  56
  57 static off_t
  58 filesize(const char * restrict fname)
  59 {
  60         struct stat st;
  61         int err;
  62
  63         err = stat(fname, &st);
  64         ATF_REQUIRE(err == 0);
  65         return st.st_size;
  66 }
  67
  68 #define TESTFILE        "./the_input_data"
  69 #define CHECKFILE       "./the_output_data"
  70 #define TESTCONTENT     "marry has a little lamb"
  71
  72 static void
  73 make_testfile(const char *restrict file)
  74 {
  75         FILE *f;
  76         size_t written;
  77
  78         f = fopen(file, "w");
  79         ATF_REQUIRE(f != NULL);
  80         written = fwrite(TESTCONTENT, 1, strlen(TESTCONTENT), f);
  81         fclose(f);
  82         ATF_REQUIRE(written == strlen(TESTCONTENT));
  83 }
  84
  85 static void
  86 empty_outfile(const char *restrict filename)
  87 {
  88         FILE *f;
  89
  90         f = fopen(filename, "w");
  91         ATF_REQUIRE(f != NULL);
  92         fclose(f);
  93 }
  94
  95 ATF_TC_BODY(t_spawn_openmode, tc)
  96 {
  97         int status, err;
  98         pid_t pid;
  99         size_t insize, outsize;
 100         char * const args[2] = { __UNCONST("cat"), NULL };
 101         posix_spawn_file_actions_t fa;
 102
 103         /*
 104          * try a "cat < testfile > checkfile"
 105          */
 106         make_testfile(TESTFILE);
 107         unlink(CHECKFILE);
 108
 109         posix_spawn_file_actions_init(&fa);
 110         posix_spawn_file_actions_addopen(&fa, fileno(stdin),
 111             TESTFILE, O_RDONLY, 0);
 112         posix_spawn_file_actions_addopen(&fa, fileno(stdout),
 113             CHECKFILE, O_WRONLY|O_CREAT, 0600);
 114         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 115         posix_spawn_file_actions_destroy(&fa);
 116
 117         ATF_REQUIRE(err == 0);
 118
 119         /* ok, wait for the child to finish */
 120         waitpid(pid, &status, 0);
 121         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 122
 123         /* now check that input and output have the same size */
 124         insize = filesize(TESTFILE);
 125         outsize = filesize(CHECKFILE);
 126         ATF_REQUIRE(insize == strlen(TESTCONTENT));
 127         ATF_REQUIRE(insize == outsize);
 128
 129         /*
 130          * try a "cat < testfile >> checkfile"
 131          */
 132         make_testfile(TESTFILE);
 133         make_testfile(CHECKFILE);
 134
 135         posix_spawn_file_actions_init(&fa);
 136         posix_spawn_file_actions_addopen(&fa, fileno(stdin),
 137             TESTFILE, O_RDONLY, 0);
 138         posix_spawn_file_actions_addopen(&fa, fileno(stdout),
 139             CHECKFILE, O_WRONLY|O_APPEND, 0);
 140         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 141         posix_spawn_file_actions_destroy(&fa);
 142
 143         ATF_REQUIRE(err == 0);
 144
 145         /* ok, wait for the child to finish */
 146         waitpid(pid, &status, 0);
 147         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 148
 149         /* now check that output is twice as long as input */
 150         insize = filesize(TESTFILE);
 151         outsize = filesize(CHECKFILE);
 152         ATF_REQUIRE(insize == strlen(TESTCONTENT));
 153         ATF_REQUIRE(insize*2 == outsize);
 154
 155         /*
 156          * try a "cat < testfile  > checkfile" with input and output swapped
 157          */
 158         make_testfile(TESTFILE);
 159         empty_outfile(CHECKFILE);
 160
 161         posix_spawn_file_actions_init(&fa);
 162         posix_spawn_file_actions_addopen(&fa, fileno(stdout),
 163             TESTFILE, O_RDONLY, 0);
 164         posix_spawn_file_actions_addopen(&fa, fileno(stdin),
 165             CHECKFILE, O_WRONLY, 0);
 166         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 167         posix_spawn_file_actions_destroy(&fa);
 168
 169         ATF_REQUIRE(err == 0);
 170
 171         /* ok, wait for the child to finish */
 172         waitpid(pid, &status, 0);
 173         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_FAILURE);
 174
 175         /* now check that input and output are still the same size */
 176         insize = filesize(TESTFILE);
 177         outsize = filesize(CHECKFILE);
 178         ATF_REQUIRE(insize == strlen(TESTCONTENT));
 179         ATF_REQUIRE(outsize == 0);
 180 }
 181
 182 ATF_TC(t_spawn_reopen);
 183
 184 ATF_TC_HEAD(t_spawn_reopen, tc)
 185 {
 186         atf_tc_set_md_var(tc, "descr",
 187             "an open filehandle can be replaced by a 'open' fileaction");
 188         atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
 189 }
 190
 191 ATF_TC_BODY(t_spawn_reopen, tc)
 192 {
 193         int status, err;
 194         pid_t pid;
 195         char * const args[2] = { __UNCONST("cat"), NULL };
 196         posix_spawn_file_actions_t fa;
 197
 198         /*
 199          * make sure stdin is open in the parent
 200          */
 201         freopen("/dev/zero", "r", stdin);
 202         /*
 203          * now request an open for this fd again in the child
 204          */
 205         posix_spawn_file_actions_init(&fa);
 206         posix_spawn_file_actions_addopen(&fa, fileno(stdin),
 207             "/dev/null", O_RDONLY, 0);
 208         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 209         posix_spawn_file_actions_destroy(&fa);
 210
 211         ATF_REQUIRE(err == 0);
 212
 213         waitpid(pid, &status, 0);
 214         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 215 }
 216
 217 ATF_TC(t_spawn_open_nonexistent);
 218
 219 ATF_TC_HEAD(t_spawn_open_nonexistent, tc)
 220 {
 221         atf_tc_set_md_var(tc, "descr",
 222             "posix_spawn fails when a file to open does not exist");
 223         atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
 224 }
 225
 226 ATF_TC_BODY(t_spawn_open_nonexistent, tc)
 227 {
 228         int err, status;
 229         pid_t pid;
 230         char * const args[2] = { __UNCONST("cat"), NULL };
 231         posix_spawn_file_actions_t fa;
 232
 233         posix_spawn_file_actions_init(&fa);
 234         posix_spawn_file_actions_addopen(&fa, STDIN_FILENO,
 235             "./non/ex/ist/ent", O_RDONLY, 0);
 236         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 237         if (err == 0) {
 238                 /*
 239                  * The child has been created - it should fail and
 240                  * return exit code 127
 241                  */
 242                 waitpid(pid, &status, 0);
 243                 ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 127);
 244         } else {
 245                 /*
 246                  * The error has been noticed early enough, no child has
 247                  * been run
 248                  */
 249                 ATF_REQUIRE(err == ENOENT);
 250         }
 251         posix_spawn_file_actions_destroy(&fa);
 252 }
 253
 254 #ifdef __NetBSD__
 255 ATF_TC(t_spawn_open_nonexistent_diag);
 256
 257 ATF_TC_HEAD(t_spawn_open_nonexistent_diag, tc)
 258 {
 259         atf_tc_set_md_var(tc, "descr",
 260             "posix_spawn fails when a file to open does not exist "
 261             "and delivers proper diagnostic");
 262         atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
 263 }
 264
 265 ATF_TC_BODY(t_spawn_open_nonexistent_diag, tc)
 266 {
 267         int err;
 268         pid_t pid;
 269         char * const args[2] = { __UNCONST("cat"), NULL };
 270         posix_spawnattr_t attr;
 271         posix_spawn_file_actions_t fa;
 272
 273         posix_spawnattr_init(&attr);
 274         /*
 275          * POSIX_SPAWN_RETURNERROR is a NetBSD specific flag that
 276          * will cause a "proper" return value from posix_spawn(2)
 277          * instead of a (potential) success there and a 127 exit
 278          * status from the child process (c.f. the non-diag variant
 279          * of this test).
 280          */
 281         posix_spawnattr_setflags(&attr, POSIX_SPAWN_RETURNERROR);
 282         posix_spawn_file_actions_init(&fa);
 283         posix_spawn_file_actions_addopen(&fa, STDIN_FILENO,
 284             "./non/ex/ist/ent", O_RDONLY, 0);
 285         err = posix_spawn(&pid, "/bin/cat", &fa, &attr, args, NULL);
 286         ATF_REQUIRE(err == ENOENT);
 287         posix_spawn_file_actions_destroy(&fa);
 288         posix_spawnattr_destroy(&attr);
 289 }
 290 #endif
 291
 292 ATF_TC(t_spawn_fileactions);
 293
 294 ATF_TC_HEAD(t_spawn_fileactions, tc)
 295 {
 296         atf_tc_set_md_var(tc, "descr",
 297             "Tests various complex fileactions");
 298 }
 299
 300 ATF_TC_BODY(t_spawn_fileactions, tc)
 301 {
 302         int fd1, fd2, fd3, status, err;
 303         pid_t pid;
 304         char * const args[2] = { __UNCONST("h_fileactions"), NULL };
 305         char helper[FILENAME_MAX];
 306         posix_spawn_file_actions_t fa;
 307
 308         posix_spawn_file_actions_init(&fa);
 309
 310         closefrom(fileno(stderr)+1);
 311
 312         fd1 = open("/dev/null", O_RDONLY);
 313         ATF_REQUIRE(fd1 == 3);
 314
 315         fd2 = open("/dev/null", O_WRONLY, O_CLOEXEC);
 316         ATF_REQUIRE(fd2 == 4);
 317
 318         fd3 = open("/dev/null", O_WRONLY);
 319         ATF_REQUIRE(fd3 == 5);
 320
 321         posix_spawn_file_actions_addclose(&fa, fd1);
 322         posix_spawn_file_actions_addopen(&fa, 6, "/dev/null", O_RDWR, 0);
 323         posix_spawn_file_actions_adddup2(&fa, 1, 7);
 324
 325         snprintf(helper, sizeof helper, "%s/h_fileactions",
 326             atf_tc_get_config_var(tc, "srcdir"));
 327         err = posix_spawn(&pid, helper, &fa, NULL, args, NULL);
 328         posix_spawn_file_actions_destroy(&fa);
 329
 330         ATF_REQUIRE(err == 0);
 331
 332         waitpid(pid, &status, 0);
 333         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 334 }
 335
 336 ATF_TC(t_spawn_empty_fileactions);
 337
 338 ATF_TC_HEAD(t_spawn_empty_fileactions, tc)
 339 {
 340         atf_tc_set_md_var(tc, "descr",
 341             "posix_spawn with empty fileactions (PR kern/46038)");
 342         atf_tc_set_md_var(tc, "require.progs", "/bin/cat");
 343 }
 344
 345 ATF_TC_BODY(t_spawn_empty_fileactions, tc)
 346 {
 347         int status, err;
 348         pid_t pid;
 349         char * const args[2] = { __UNCONST("cat"), NULL };
 350         posix_spawn_file_actions_t fa;
 351         size_t insize, outsize;
 352
 353         /*
 354          * try a "cat < testfile > checkfile", but set up stdin/stdout
 355          * already in the parent and pass empty file actions to the child.
 356          */
 357         make_testfile(TESTFILE);
 358         unlink(CHECKFILE);
 359
 360         freopen(TESTFILE, "r", stdin);
 361         freopen(CHECKFILE, "w", stdout);
 362
 363         posix_spawn_file_actions_init(&fa);
 364         err = posix_spawn(&pid, "/bin/cat", &fa, NULL, args, NULL);
 365         posix_spawn_file_actions_destroy(&fa);
 366
 367         ATF_REQUIRE(err == 0);
 368
 369         /* ok, wait for the child to finish */
 370         waitpid(pid, &status, 0);
 371         ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
 372
 373         /* now check that input and output have the same size */
 374         insize = filesize(TESTFILE);
 375         outsize = filesize(CHECKFILE);
 376         ATF_REQUIRE(insize == strlen(TESTCONTENT));
 377         ATF_REQUIRE(insize == outsize);
 378 }
 379
 380 ATF_TP_ADD_TCS(tp)
 381 {
 382         ATF_TP_ADD_TC(tp, t_spawn_fileactions);
 383         ATF_TP_ADD_TC(tp, t_spawn_open_nonexistent);
 384 #ifdef __NetBSD__
 385         ATF_TP_ADD_TC(tp, t_spawn_open_nonexistent_diag);
 386 #endif
 387         ATF_TP_ADD_TC(tp, t_spawn_reopen);
 388         ATF_TP_ADD_TC(tp, t_spawn_openmode);
 389         ATF_TP_ADD_TC(tp, t_spawn_empty_fileactions);
 390
 391         return atf_no_error();
 392 }