1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 2013 by Delphix. All rights reserved. 29 */ 30 31 /* 32 * Copyright (c) 2018, Joyent, Inc. 33 */ 34 35 #include <sys/types.h> 36 #include <sys/stat.h> 37 #include <utime.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <unistd.h> 41 #include <strings.h> 42 #include <errno.h> 43 #include <fcntl.h> 44 #include <libgen.h> 45 46 #define ST_ATIME 0 47 #define ST_CTIME 1 48 #define ST_MTIME 2 49 50 #define ALL_MODE (mode_t)(S_IRWXU|S_IRWXG|S_IRWXO) 51 52 typedef struct timetest { 53 int type; 54 char *name; 55 int (*func)(const char *pfile); 56 } timetest_t; 57 58 static char tfile[BUFSIZ] = { 0 }; 59 60 extern int errno; 61 62 /* 63 * DESCRIPTION: 64 * Verify time will be changed correctly after each operation. 65 * 66 * STRATEGY: 67 * 1. Define time test array. 68 * 2. Loop through each item in this array. 69 * 3. Verify the time is changed after each operation. 70 * 71 */ 72 73 static int 74 get_file_time(const char *pfile, int what, time_t *ptr) 75 { 76 struct stat stat_buf; 77 78 if (pfile == NULL || ptr == NULL) { 79 return (-1); 80 } 81 82 if (stat(pfile, &stat_buf) == -1) { 83 return (-1); 84 } 85 86 switch (what) { 87 case ST_ATIME: 88 *ptr = stat_buf.st_atime; 89 return (0); 90 case ST_CTIME: 91 *ptr = stat_buf.st_ctime; 92 return (0); 93 case ST_MTIME: 94 *ptr = stat_buf.st_mtime; 95 return (0); 96 default: 97 return (-1); 98 } 99 } 100 101 static int 102 do_read(const char *pfile) 103 { 104 int fd, ret = 0; 105 char buf[BUFSIZ] = { 0 }; 106 107 if (pfile == NULL) { 108 return (-1); 109 } 110 111 if ((fd = open(pfile, O_RDONLY, ALL_MODE)) == -1) { 112 return (-1); 113 } 114 if (read(fd, buf, sizeof (buf)) == -1) { 115 (void) fprintf(stderr, "read(%d, buf, %d) failed with errno " 116 "%d\n", fd, sizeof (buf), errno); 117 return (1); 118 } 119 (void) close(fd); 120 121 return (ret); 122 } 123 124 static int 125 do_write(const char *pfile) 126 { 127 int fd, ret = 0; 128 char buf[BUFSIZ] = "call function do_write()"; 129 130 if (pfile == NULL) { 131 return (-1); 132 } 133 134 if ((fd = open(pfile, O_WRONLY, ALL_MODE)) == -1) { 135 return (-1); 136 } 137 if (write(fd, buf, strlen(buf)) == -1) { 138 (void) fprintf(stderr, "write(%d, buf, %d) failed with errno " 139 "%d\n", fd, strlen(buf), errno); 140 return (1); 141 } 142 (void) close(fd); 143 144 return (ret); 145 } 146 147 static int 148 do_link(const char *pfile) 149 { 150 int ret = 0; 151 char link_file[BUFSIZ] = { 0 }; 152 char *dname; 153 154 if (pfile == NULL) { 155 return (-1); 156 } 157 158 /* 159 * Figure out source file directory name, and create 160 * the link file in the same directory. 161 */ 162 dname = dirname(strdup(pfile)); 163 (void) snprintf(link_file, BUFSIZ, "%s/%s", dname, "link_file"); 164 165 if (link(pfile, link_file) == -1) { 166 (void) fprintf(stderr, "link(%s, %s) failed with errno %d\n", 167 pfile, link_file, errno); 168 free((void *)dirname); 169 return (1); 170 } 171 172 (void) unlink(link_file); 173 free((void *)dirname); 174 return (ret); 175 } 176 177 static int 178 do_creat(const char *pfile) 179 { 180 int fd, ret = 0; 181 182 if (pfile == NULL) { 183 return (-1); 184 } 185 186 if ((fd = creat(pfile, ALL_MODE)) == -1) { 187 (void) fprintf(stderr, "creat(%s, ALL_MODE) failed with errno " 188 "%d\n", pfile, errno); 189 return (1); 190 } 191 (void) close(fd); 192 193 return (ret); 194 } 195 196 static int 197 do_utime(const char *pfile) 198 { 199 int ret = 0; 200 201 if (pfile == NULL) { 202 return (-1); 203 } 204 205 /* 206 * Times of the file are set to the current time 207 */ 208 if (utime(pfile, NULL) == -1) { 209 (void) fprintf(stderr, "utime(%s, NULL) failed with errno " 210 "%d\n", pfile, errno); 211 return (1); 212 } 213 214 return (ret); 215 } 216 217 static int 218 do_chmod(const char *pfile) 219 { 220 int ret = 0; 221 222 if (pfile == NULL) { 223 return (-1); 224 } 225 226 if (chmod(pfile, ALL_MODE) == -1) { 227 (void) fprintf(stderr, "chmod(%s, ALL_MODE) failed with " 228 "errno %d\n", pfile, errno); 229 return (1); 230 } 231 232 return (ret); 233 } 234 235 static int 236 do_chown(const char *pfile) 237 { 238 int ret = 0; 239 240 if (pfile == NULL) { 241 return (-1); 242 } 243 244 if (chown(pfile, getuid(), getgid()) == -1) { 245 (void) fprintf(stderr, "chown(%s, %d, %d) failed with errno " 246 "%d\n", pfile, (int)getuid(), (int)getgid(), errno); 247 return (1); 248 } 249 250 return (ret); 251 } 252 253 static void 254 cleanup(void) 255 { 256 if ((strlen(tfile) != 0) && (access(tfile, F_OK) == 0)) { 257 (void) unlink(tfile); 258 } 259 } 260 261 static timetest_t timetest_table[] = { 262 { ST_ATIME, "st_atime", do_read }, 263 { ST_ATIME, "st_atime", do_utime }, 264 { ST_MTIME, "st_mtime", do_creat }, 265 { ST_MTIME, "st_mtime", do_write }, 266 { ST_MTIME, "st_mtime", do_utime }, 267 { ST_CTIME, "st_ctime", do_creat }, 268 { ST_CTIME, "st_ctime", do_write }, 269 { ST_CTIME, "st_ctime", do_chmod }, 270 { ST_CTIME, "st_ctime", do_chown }, 271 { ST_CTIME, "st_ctime", do_link }, 272 { ST_CTIME, "st_ctime", do_utime }, 273 }; 274 275 #define NCOMMAND (sizeof (timetest_table) / sizeof (timetest_table[0])) 276 277 /* ARGSUSED */ 278 int 279 main(int argc, char *argv[]) 280 { 281 int i, ret, fd; 282 char *penv[] = {"TESTDIR", "TESTFILE0"}; 283 284 (void) fprintf(stdout, "Verify [acm]time is modified appropriately.\n"); 285 (void) atexit(cleanup); 286 287 /* 288 * Get the environment variable values. 289 */ 290 for (i = 0; i < sizeof (penv) / sizeof (char *); i++) { 291 if ((penv[i] = getenv(penv[i])) == NULL) { 292 (void) fprintf(stderr, "getenv(penv[%d])\n", i); 293 return (1); 294 } 295 } 296 (void) snprintf(tfile, sizeof (tfile), "%s/%s", penv[0], penv[1]); 297 298 /* 299 * If the test file is exists, remove it first. 300 */ 301 if (access(tfile, F_OK) == 0) { 302 (void) unlink(tfile); 303 } 304 ret = 0; 305 if ((fd = open(tfile, O_WRONLY | O_CREAT | O_TRUNC, ALL_MODE)) == -1) { 306 (void) fprintf(stderr, "open(%s) failed: %d\n", tfile, errno); 307 return (1); 308 } 309 (void) close(fd); 310 311 for (i = 0; i < NCOMMAND; i++) { 312 time_t t1, t2; 313 314 /* 315 * Get original time before operating. 316 */ 317 ret = get_file_time(tfile, timetest_table[i].type, &t1); 318 if (ret != 0) { 319 (void) fprintf(stderr, "get_file_time(%s %d) = %d\n", 320 tfile, timetest_table[i].type, ret); 321 return (1); 322 } 323 324 /* 325 * Sleep 2 seconds, then invoke command on given file 326 */ 327 (void) sleep(2); 328 (void) timetest_table[i].func(tfile); 329 330 /* 331 * Get time after operating. 332 */ 333 ret = get_file_time(tfile, timetest_table[i].type, &t2); 334 if (ret != 0) { 335 (void) fprintf(stderr, "get_file_time(%s %d) = %d\n", 336 tfile, timetest_table[i].type, ret); 337 return (1); 338 } 339 340 if (t1 == t2) { 341 (void) fprintf(stderr, "%s: t1(%ld) == t2(%ld)\n", 342 timetest_table[i].name, (long)t1, (long)t2); 343 return (1); 344 } else { 345 (void) fprintf(stderr, "%s: t1(%ld) != t2(%ld)\n", 346 timetest_table[i].name, (long)t1, (long)t2); 347 } 348 } 349 350 (void) fprintf(stdout, "PASS\n"); 351 return (0); 352 } 353