2 Copyright (C) 2009 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Eric Blake <ebb9@byu.net>, 2009. */
19 #ifndef TEST_CHOWN_NAP
20 /* Sleep long enough to notice a timestamp difference on the file
21 system in the current directory. */
26 /* Assume the worst case file system of FAT, which has a granularity
29 # else /* HAVE_USLEEP */
33 /* Initialize only once, by sleeping for 20 milliseconds (needed
34 since xfs has a quantization of about 10 milliseconds, even
35 though it has a granularity of 1 nanosecond, and since NTFS
36 has a default quantization of 15.25 milliseconds, even though
37 it has a granularity of 100 nanoseconds). If the seconds
38 differ, repeat the test one more time (in case we crossed a
39 quantization boundary on a file system with 1 second
40 resolution). If we can't observe a difference in only the
41 nanoseconds, then fall back to 2 seconds. However, note that
42 usleep (2000000) is allowed to fail with EINVAL. */
45 ASSERT (close (creat (BASE "tmp", 0600)) == 0);
46 ASSERT (stat (BASE "tmp", &st1) == 0);
47 ASSERT (unlink (BASE "tmp") == 0);
50 ASSERT (close (creat (BASE "tmp", 0600)) == 0);
51 ASSERT (stat (BASE "tmp", &st2) == 0);
52 ASSERT (unlink (BASE "tmp") == 0);
53 if (st1.st_mtime != st2.st_mtime)
55 /* Seconds differ, give it one more shot. */
58 ASSERT (close (creat (BASE "tmp", 0600)) == 0);
59 ASSERT (stat (BASE "tmp", &st2) == 0);
60 ASSERT (unlink (BASE "tmp") == 0);
62 if (! (st1.st_mtime == st2.st_mtime
63 && get_stat_mtime_ns (&st1) < get_stat_mtime_ns (&st2)))
70 # endif /* HAVE_USLEEP */
72 #endif /* !TEST_CHOWN_NAP */
75 # define getegid() (-1)
78 /* This file is designed to test lchown(n,o,g) and
79 chownat(AT_FDCWD,n,o,g,AT_SYMLINK_NOFOLLOW). FUNC is the function
80 to test. Assumes that BASE and ASSERT are already defined, and
81 that appropriate headers are already included. If PRINT, warn
82 before skipping symlink tests with status 77. */
85 test_lchown (int (*func) (char const *, uid_t, gid_t), bool print)
93 /* Solaris 8 is interesting - if the current process belongs to
94 multiple groups, the current directory is owned by a a group that
95 the current process belongs to but different than getegid(), and
96 the current directory does not have the S_ISGID bit, then regular
97 files created in the directory belong to the directory's group,
98 but symlinks belong to the current effective group id. If
99 S_ISGID is set, then both files and symlinks belong to the
100 directory's group. However, it is possible to run the testsuite
101 from within a directory owned by a group we don't belong to, in
102 which case all things that we create belong to the current
103 effective gid. So, work around the issues by creating a
104 subdirectory (we are guaranteed that the subdirectory will be
105 owned by one of our current groups), change ownership of that
106 directory to the current effective gid (which will thus succeed),
107 then create all other files within that directory (eliminating
108 questions on whether inheritance or current id triumphs, since
109 the two methods resolve to the same gid). */
110 ASSERT (mkdir (BASE "dir", 0700) == 0);
111 ASSERT (stat (BASE "dir", &st1) == 0);
113 /* Filter out mingw, which has no concept of groups. */
114 result = func (BASE "dir", st1.st_uid, getegid ());
115 if (result == -1 && errno == ENOSYS)
117 ASSERT (rmdir (BASE "dir") == 0);
119 fputs ("skipping test: no support for ownership\n", stderr);
122 ASSERT (result == 0);
124 ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
125 ASSERT (stat (BASE "dir/file", &st1) == 0);
126 ASSERT (st1.st_uid != -1);
127 ASSERT (st1.st_gid != -1);
128 ASSERT (st1.st_gid == getegid ());
130 /* Sanity check of error cases. */
132 ASSERT (func ("", -1, -1) == -1);
133 ASSERT (errno == ENOENT);
135 ASSERT (func ("no_such", -1, -1) == -1);
136 ASSERT (errno == ENOENT);
138 ASSERT (func ("no_such/", -1, -1) == -1);
139 ASSERT (errno == ENOENT);
141 ASSERT (func (BASE "dir/file/", -1, -1) == -1);
142 ASSERT (errno == ENOTDIR);
144 /* Check that -1 does not alter ownership. */
145 ASSERT (func (BASE "dir/file", -1, st1.st_gid) == 0);
146 ASSERT (func (BASE "dir/file", st1.st_uid, -1) == 0);
147 ASSERT (stat (BASE "dir/file", &st2) == 0);
148 ASSERT (st1.st_uid == st2.st_uid);
149 ASSERT (st1.st_gid == st2.st_gid);
151 /* Even if the values aren't changing, ctime is required to change
152 if at least one argument is not -1. */
154 ASSERT (func (BASE "dir/file", st1.st_uid, st1.st_gid) == 0);
155 ASSERT (stat (BASE "dir/file", &st2) == 0);
156 ASSERT (st1.st_ctime < st2.st_ctime
157 || (st1.st_ctime == st2.st_ctime
158 && get_stat_ctime_ns (&st1) < get_stat_ctime_ns (&st2)));
160 /* Test symlink behavior. */
161 if (symlink ("link", BASE "dir/link2"))
163 ASSERT (unlink (BASE "dir/file") == 0);
164 ASSERT (rmdir (BASE "dir") == 0);
166 fputs ("skipping test: symlinks not supported on this file system\n",
170 result = func (BASE "dir/link2", -1, -1);
171 if (result == -1 && errno == ENOSYS)
173 ASSERT (unlink (BASE "dir/file") == 0);
174 ASSERT (unlink (BASE "dir/link2") == 0);
175 ASSERT (rmdir (BASE "dir") == 0);
177 fputs ("skipping test: symlink ownership not supported\n", stderr);
180 ASSERT (result == 0);
182 ASSERT (func (BASE "dir/link2/", st1.st_uid, st1.st_gid) == -1);
183 ASSERT (errno == ENOENT);
184 ASSERT (symlink ("file", BASE "dir/link") == 0);
185 ASSERT (mkdir (BASE "dir/sub", 0700) == 0);
186 ASSERT (symlink ("sub", BASE "dir/link3") == 0);
188 /* For non-privileged users, lchown can only portably succeed at
189 changing group ownership of a file we own. If we belong to at
190 least two groups, then verifying the correct change is simple.
191 But if we belong to only one group, then we fall back on the
192 other observable effect of lchown: the ctime must be updated.
193 Be careful of duplicates returned by getgroups. */
194 gids_count = mgetgroups (NULL, -1, &gids);
195 if (2 <= gids_count && gids[0] == gids[1] && 2 < gids_count--)
197 if (1 < gids_count || (gids_count == 1 && gids[0] != st1.st_gid))
199 if (gids[0] == st1.st_gid)
201 ASSERT (1 < gids_count);
202 ASSERT (gids[0] != gids[1]);
205 ASSERT (gids[0] != st1.st_gid);
206 ASSERT (gids[0] != -1);
207 ASSERT (lstat (BASE "dir/link", &st2) == 0);
208 ASSERT (st1.st_uid == st2.st_uid);
209 ASSERT (st1.st_gid == st2.st_gid);
210 ASSERT (lstat (BASE "dir/link2", &st2) == 0);
211 ASSERT (st1.st_uid == st2.st_uid);
212 ASSERT (st1.st_gid == st2.st_gid);
215 ASSERT (func (BASE "dir/link2/", -1, gids[0]) == -1);
216 ASSERT (errno == ENOTDIR);
217 ASSERT (stat (BASE "dir/file", &st2) == 0);
218 ASSERT (st1.st_uid == st2.st_uid);
219 ASSERT (st1.st_gid == st2.st_gid);
220 ASSERT (lstat (BASE "dir/link", &st2) == 0);
221 ASSERT (st1.st_uid == st2.st_uid);
222 ASSERT (st1.st_gid == st2.st_gid);
223 ASSERT (lstat (BASE "dir/link2", &st2) == 0);
224 ASSERT (st1.st_uid == st2.st_uid);
225 ASSERT (st1.st_gid == st2.st_gid);
227 ASSERT (func (BASE "dir/link2", -1, gids[0]) == 0);
228 ASSERT (stat (BASE "dir/file", &st2) == 0);
229 ASSERT (st1.st_uid == st2.st_uid);
230 ASSERT (st1.st_gid == st2.st_gid);
231 ASSERT (lstat (BASE "dir/link", &st2) == 0);
232 ASSERT (st1.st_uid == st2.st_uid);
233 ASSERT (st1.st_gid == st2.st_gid);
234 ASSERT (lstat (BASE "dir/link2", &st2) == 0);
235 ASSERT (st1.st_uid == st2.st_uid);
236 ASSERT (gids[0] == st2.st_gid);
238 /* Trailing slash follows through to directory. */
239 ASSERT (lstat (BASE "dir/link3", &st2) == 0);
240 ASSERT (st1.st_uid == st2.st_uid);
241 ASSERT (st1.st_gid == st2.st_gid);
242 ASSERT (lstat (BASE "dir/sub", &st2) == 0);
243 ASSERT (st1.st_uid == st2.st_uid);
244 ASSERT (st1.st_gid == st2.st_gid);
246 ASSERT (func (BASE "dir/link3/", -1, gids[0]) == 0);
247 ASSERT (lstat (BASE "dir/link3", &st2) == 0);
248 ASSERT (st1.st_uid == st2.st_uid);
249 ASSERT (st1.st_gid == st2.st_gid);
250 ASSERT (lstat (BASE "dir/sub", &st2) == 0);
251 ASSERT (st1.st_uid == st2.st_uid);
252 ASSERT (gids[0] == st2.st_gid);
258 ASSERT (stat (BASE "dir/file", &st1) == 0);
259 ASSERT (lstat (BASE "dir/link", &l1) == 0);
260 ASSERT (lstat (BASE "dir/link2", &l2) == 0);
264 ASSERT (func (BASE "dir/link2/", -1, st1.st_gid) == -1);
265 ASSERT (errno == ENOTDIR);
266 ASSERT (stat (BASE "dir/file", &st2) == 0);
267 ASSERT (st1.st_ctime == st2.st_ctime);
268 ASSERT (get_stat_ctime_ns (&st1) == get_stat_ctime_ns (&st2));
269 ASSERT (lstat (BASE "dir/link", &st2) == 0);
270 ASSERT (l1.st_ctime == st2.st_ctime);
271 ASSERT (get_stat_ctime_ns (&l1) == get_stat_ctime_ns (&st2));
272 ASSERT (lstat (BASE "dir/link2", &st2) == 0);
273 ASSERT (l2.st_ctime == st2.st_ctime);
274 ASSERT (get_stat_ctime_ns (&l2) == get_stat_ctime_ns (&st2));
276 ASSERT (func (BASE "dir/link2", -1, gids[0]) == 0);
277 ASSERT (stat (BASE "dir/file", &st2) == 0);
278 ASSERT (st1.st_ctime == st2.st_ctime);
279 ASSERT (get_stat_ctime_ns (&st1) == get_stat_ctime_ns (&st2));
280 ASSERT (lstat (BASE "dir/link", &st2) == 0);
281 ASSERT (l1.st_ctime == st2.st_ctime);
282 ASSERT (get_stat_ctime_ns (&l1) == get_stat_ctime_ns (&st2));
283 ASSERT (lstat (BASE "dir/link2", &st2) == 0);
284 ASSERT (l2.st_ctime < st2.st_ctime
285 || (l2.st_ctime == st2.st_ctime
286 && get_stat_ctime_ns (&l2) < get_stat_ctime_ns (&st2)));
288 /* Trailing slash follows through to directory. */
289 ASSERT (lstat (BASE "dir/sub", &st1) == 0);
290 ASSERT (lstat (BASE "dir/link3", &l1) == 0);
292 ASSERT (func (BASE "dir/link3/", -1, gids[0]) == 0);
293 ASSERT (lstat (BASE "dir/link3", &st2) == 0);
294 ASSERT (l1.st_ctime == st2.st_ctime);
295 ASSERT (get_stat_ctime_ns (&l1) == get_stat_ctime_ns (&st2));
296 ASSERT (lstat (BASE "dir/sub", &st2) == 0);
297 ASSERT (st1.st_ctime < st2.st_ctime
298 || (st1.st_ctime == st2.st_ctime
299 && get_stat_ctime_ns (&st1) < get_stat_ctime_ns (&st2)));
304 ASSERT (unlink (BASE "dir/file") == 0);
305 ASSERT (unlink (BASE "dir/link") == 0);
306 ASSERT (unlink (BASE "dir/link2") == 0);
307 ASSERT (unlink (BASE "dir/link3") == 0);
308 ASSERT (rmdir (BASE "dir/sub") == 0);
309 ASSERT (rmdir (BASE "dir") == 0);