fifo_create.c revision 149959
1/*- 2 * Copyright (c) 2005 Robert N. M. Watson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: head/tools/regression/fifo/fifo_create/fifo_create.c 149959 2005-09-10 21:09:26Z rwatson $ 27 */ 28 29#include <sys/stat.h> 30 31#include <err.h> 32#include <errno.h> 33#include <limits.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37#include <unistd.h> 38 39/* 40 * Simple regression test for the creation and destruction of POSIX fifos in 41 * the file system name space. Using a specially created directory, create 42 * a fifo in it and check that the following properties are present, as 43 * specified in IEEE Std 1003.1, 2004 Edition: 44 * 45 * - When mkfifo() is called, on success, a fifo is created. 46 * 47 * - On an error, no fifo is created. (XXX: Not tested) 48 * 49 * - The mode bits on the fifo are a product of combining the umask and 50 * requested mode. 51 * 52 * - The fifo's owner will be the processes effective user ID. (XXX: Not 53 * tested) 54 * 55 * - The fifo's group will be the parent directory's group or the effective 56 * group ID of the process. For historical reasons, BSD prefers the group 57 * ID of the process, so we will generate an error if it's not that. (XXX: 58 * Not tested) 59 * 60 * - The st_atime, st_ctime, st_mtime of the fifo will be set appropriately, 61 * and st_ctime and st_mtime on the directory will be updated. (XXX: We 62 * test they are updated, not correct) 63 * 64 * - EEXIST is returned if the named file already exists. 65 * 66 * In addition, we check that we can unlink the fifo, and that if we do, it 67 * disappears. 68 * 69 * This test must run as root in order to usefully frob the process 70 * credential to test permission parts. 71 */ 72 73/* 74 * All activity occurs within a temporary directory created early in the 75 * test. 76 */ 77char temp_dir[PATH_MAX]; 78 79static void __unused 80atexit_temp_dir(void) 81{ 82 83 rmdir(temp_dir); 84} 85 86/* 87 * Basic creation tests: verify that mkfifo() creates a fifo, that the time 88 * stamps on the directory are updated, that if we try twice we get EEXIST, 89 * and that we can unlink it. 90 */ 91static void 92fifo_create_test(void) 93{ 94 struct stat old_dirsb, dirsb, fifosb; 95 char path[PATH_MAX]; 96 int error; 97 98 /* 99 * Sleep to make sure that the time stamp on the directory will be 100 * updated. 101 */ 102 sleep(2); 103 104 if (stat(temp_dir, &old_dirsb) < 0) 105 err(-1, "basic_create_test: stat: %s", temp_dir); 106 107 snprintf(path, PATH_MAX, "%s/testfifo", temp_dir); 108 109 if (mkfifo(path, 0600) < 0) 110 err(-1, "basic_create_test: mkfifo: %s", path); 111 112 if (stat(path, &fifosb) < 0) { 113 error = errno; 114 (void)unlink(path); 115 errno = error; 116 err(-1, "basic_create_test: stat: %s", path); 117 } 118 119 if (!(S_ISFIFO(fifosb.st_mode))) { 120 (void)unlink(path); 121 errx(-1, "basic_create_test: mkfifo produced non-fifo"); 122 } 123 124 if (mkfifo(path, 0600) == 0) 125 errx(-1, "basic_create_test: dup mkfifo succeeded"); 126 127 if (errno != EEXIST) 128 err(-1, "basic_create_test: dup mkfifo unexpected error"); 129 130 if (stat(temp_dir, &dirsb) < 0) { 131 error = errno; 132 (void)unlink(path); 133 errno = error; 134 err(-1, "basic_create_test: stat: %s", temp_dir); 135 } 136 137 if (old_dirsb.st_ctime == dirsb.st_ctime) { 138 (void)unlink(path); 139 errx(-1, "basic_create_test: old_dirsb.st_ctime == " 140 "dirsb.st_ctime"); 141 } 142 143 if (old_dirsb.st_mtime == dirsb.st_mtime) { 144 (void)unlink(path); 145 errx(-1, "basic_create_test: old_dirsb.st_mtime == " 146 "dirsb.st_mtime"); 147 } 148 149 if (unlink(path) < 0) 150 err(-1, "basic_create_test: unlink: %s", path); 151 152 if (stat(path, &fifosb) == 0) 153 errx(-1, "basic_create_test: unlink failed to unlink"); 154 if (errno != ENOENT) 155 err(-1, "basic_create_test: unlink unexpected error"); 156} 157 158/* 159 * Having determined that basic create/remove/etc functionality is present 160 * for fifos, now make sure that the umask, requested permissions, and 161 * resulting mode are handled properly. 162 */ 163static const struct permission_test { 164 mode_t pt_umask; 165 mode_t pt_reqmode; 166 mode_t pt_mode; 167} permission_test[] = { 168 {0000, 0, S_IFIFO}, 169 {0000, S_IRWXU, S_IFIFO | S_IRWXU}, 170 {0000, S_IRWXU | S_IRWXG | S_IRWXO, S_IFIFO | S_IRWXU | S_IRWXG | 171 S_IRWXO }, 172 {0077, S_IRWXU, S_IFIFO | S_IRWXU}, 173 {0077, S_IRWXU | S_IRWXG | S_IRWXO, S_IFIFO | S_IRWXU}, 174}; 175static const int permission_test_count = sizeof(permission_test) / 176 sizeof(struct permission_test); 177 178static void 179fifo_permission_test(void) 180{ 181 const struct permission_test *ptp; 182 mode_t __unused old_umask; 183 char path[PATH_MAX]; 184 struct stat sb; 185 int error, i; 186 187 snprintf(path, PATH_MAX, "%s/testfifo", temp_dir); 188 old_umask = umask(0022); 189 for (i = 0; i < permission_test_count; i++) { 190 ptp = &permission_test[i]; 191 192 umask(ptp->pt_umask); 193 if (mkfifo(path, ptp->pt_reqmode) < 0) 194 err(-1, "fifo_permission_test: %08o %08o %08o\n", 195 ptp->pt_umask, ptp->pt_reqmode, ptp->pt_mode); 196 197 if (stat(path, &sb) < 0) { 198 error = errno; 199 (void)unlink(path); 200 errno = error; 201 err(-1, "fifo_permission_test: %s", path); 202 } 203 204 if (sb.st_mode != ptp->pt_mode) { 205 (void)unlink(path); 206 errx(-1, "fifo_permission_test: %08o %08o %08o " 207 "got %08o", ptp->pt_umask, ptp->pt_reqmode, 208 ptp->pt_mode, sb.st_mode); 209 } 210 211 if (unlink(path) < 0) 212 err(-1, "fifo_permission_test: unlink: %s", path); 213 } 214 umask(old_umask); 215} 216 217int 218main(int argc, char *argv[]) 219{ 220 221 if (geteuid() != 0) 222 errx(-1, "must be run as root"); 223 224 strcpy(temp_dir, "/tmp/fifo_create.XXXXXXXXXXX"); 225 if (mkdtemp(temp_dir) == NULL) 226 err(-1, "mkdtemp"); 227 atexit(atexit_temp_dir); 228 229 if (chdir(temp_dir) < 0) 230 err(-1, "chdir"); 231 232 fifo_create_test(); 233 234 fifo_permission_test(); 235 236 return (0); 237} 238