]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
c270684a RC |
2 | |
3 | #include <unistd.h> | |
4 | ||
5 | #include "alloc-util.h" | |
c270684a RC |
6 | #include "fd-util.h" |
7 | #include "fs-util.h" | |
1ed34d75 | 8 | #include "id128-util.h" |
c270684a RC |
9 | #include "macro.h" |
10 | #include "mkdir.h" | |
d944dc95 | 11 | #include "path-util.h" |
c270684a | 12 | #include "rm-rf.h" |
1ed34d75 | 13 | #include "stdio-util.h" |
c270684a RC |
14 | #include "string-util.h" |
15 | #include "strv.h" | |
27964854 | 16 | #include "tests.h" |
e4de7287 | 17 | #include "tmpfile-util.h" |
c1447be4 | 18 | #include "umask-util.h" |
f14f1806 | 19 | #include "user-util.h" |
c270684a | 20 | #include "util.h" |
9590065f | 21 | #include "virt.h" |
c270684a | 22 | |
27964854 ZJS |
23 | static const char *arg_test_dir = NULL; |
24 | ||
d944dc95 | 25 | static void test_chase_symlinks(void) { |
c9825701 | 26 | _cleanup_free_ char *result = NULL; |
27964854 | 27 | char *temp; |
b12d25a8 | 28 | const char *top, *p, *pslash, *q, *qslash; |
1f56e4ce | 29 | struct stat st; |
1ed34d75 | 30 | int r, pfd; |
d944dc95 | 31 | |
27964854 ZJS |
32 | log_info("/* %s */", __func__); |
33 | ||
34 | temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX"); | |
d944dc95 LP |
35 | assert_se(mkdtemp(temp)); |
36 | ||
37 | top = strjoina(temp, "/top"); | |
38 | assert_se(mkdir(top, 0700) >= 0); | |
39 | ||
40 | p = strjoina(top, "/dot"); | |
27964854 ZJS |
41 | if (symlink(".", p) < 0) { |
42 | assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM)); | |
43 | log_tests_skipped_errno(errno, "symlink() not possible"); | |
44 | goto cleanup; | |
45 | }; | |
d944dc95 LP |
46 | |
47 | p = strjoina(top, "/dotdot"); | |
48 | assert_se(symlink("..", p) >= 0); | |
49 | ||
50 | p = strjoina(top, "/dotdota"); | |
51 | assert_se(symlink("../a", p) >= 0); | |
52 | ||
53 | p = strjoina(temp, "/a"); | |
54 | assert_se(symlink("b", p) >= 0); | |
55 | ||
56 | p = strjoina(temp, "/b"); | |
57 | assert_se(symlink("/usr", p) >= 0); | |
58 | ||
59 | p = strjoina(temp, "/start"); | |
60 | assert_se(symlink("top/dot/dotdota", p) >= 0); | |
61 | ||
df878e68 ZJS |
62 | /* Paths that use symlinks underneath the "root" */ |
63 | ||
c4f4fce7 | 64 | r = chase_symlinks(p, NULL, 0, &result); |
a9fb0867 | 65 | assert_se(r > 0); |
d944dc95 | 66 | assert_se(path_equal(result, "/usr")); |
b12d25a8 | 67 | result = mfree(result); |
d944dc95 | 68 | |
b12d25a8 ZJS |
69 | pslash = strjoina(p, "/"); |
70 | r = chase_symlinks(pslash, NULL, 0, &result); | |
71 | assert_se(r > 0); | |
72 | assert_se(path_equal(result, "/usr/")); | |
d944dc95 | 73 | result = mfree(result); |
b12d25a8 | 74 | |
c4f4fce7 | 75 | r = chase_symlinks(p, temp, 0, &result); |
d944dc95 LP |
76 | assert_se(r == -ENOENT); |
77 | ||
b12d25a8 ZJS |
78 | r = chase_symlinks(pslash, temp, 0, &result); |
79 | assert_se(r == -ENOENT); | |
80 | ||
d944dc95 | 81 | q = strjoina(temp, "/usr"); |
a9fb0867 | 82 | |
cb638b5e | 83 | r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result); |
a9fb0867 LP |
84 | assert_se(r == 0); |
85 | assert_se(path_equal(result, q)); | |
b12d25a8 | 86 | result = mfree(result); |
a9fb0867 | 87 | |
b12d25a8 | 88 | qslash = strjoina(q, "/"); |
d944dc95 | 89 | |
b12d25a8 ZJS |
90 | r = chase_symlinks(pslash, temp, CHASE_NONEXISTENT, &result); |
91 | assert_se(r == 0); | |
92 | assert_se(path_equal(result, qslash)); | |
f4b85a0f | 93 | result = mfree(result); |
b12d25a8 ZJS |
94 | |
95 | assert_se(mkdir(q, 0700) >= 0); | |
96 | ||
c4f4fce7 | 97 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 98 | assert_se(r > 0); |
d944dc95 | 99 | assert_se(path_equal(result, q)); |
b12d25a8 ZJS |
100 | result = mfree(result); |
101 | ||
102 | r = chase_symlinks(pslash, temp, 0, &result); | |
103 | assert_se(r > 0); | |
104 | assert_se(path_equal(result, qslash)); | |
105 | result = mfree(result); | |
d944dc95 LP |
106 | |
107 | p = strjoina(temp, "/slash"); | |
108 | assert_se(symlink("/", p) >= 0); | |
109 | ||
c4f4fce7 | 110 | r = chase_symlinks(p, NULL, 0, &result); |
a9fb0867 | 111 | assert_se(r > 0); |
d944dc95 | 112 | assert_se(path_equal(result, "/")); |
d944dc95 | 113 | result = mfree(result); |
b12d25a8 | 114 | |
c4f4fce7 | 115 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 116 | assert_se(r > 0); |
d944dc95 | 117 | assert_se(path_equal(result, temp)); |
b12d25a8 | 118 | result = mfree(result); |
d944dc95 | 119 | |
df878e68 ZJS |
120 | /* Paths that would "escape" outside of the "root" */ |
121 | ||
122 | p = strjoina(temp, "/6dots"); | |
123 | assert_se(symlink("../../..", p) >= 0); | |
124 | ||
c4f4fce7 | 125 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 126 | assert_se(r > 0 && path_equal(result, temp)); |
b12d25a8 | 127 | result = mfree(result); |
df878e68 ZJS |
128 | |
129 | p = strjoina(temp, "/6dotsusr"); | |
130 | assert_se(symlink("../../../usr", p) >= 0); | |
131 | ||
c4f4fce7 | 132 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 133 | assert_se(r > 0 && path_equal(result, q)); |
b12d25a8 | 134 | result = mfree(result); |
df878e68 ZJS |
135 | |
136 | p = strjoina(temp, "/top/8dotsusr"); | |
137 | assert_se(symlink("../../../../usr", p) >= 0); | |
138 | ||
c4f4fce7 | 139 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 140 | assert_se(r > 0 && path_equal(result, q)); |
b12d25a8 | 141 | result = mfree(result); |
df878e68 ZJS |
142 | |
143 | /* Paths that contain repeated slashes */ | |
144 | ||
d944dc95 LP |
145 | p = strjoina(temp, "/slashslash"); |
146 | assert_se(symlink("///usr///", p) >= 0); | |
147 | ||
c4f4fce7 | 148 | r = chase_symlinks(p, NULL, 0, &result); |
a9fb0867 | 149 | assert_se(r > 0); |
d944dc95 | 150 | assert_se(path_equal(result, "/usr")); |
d944dc95 | 151 | result = mfree(result); |
b12d25a8 | 152 | |
c4f4fce7 | 153 | r = chase_symlinks(p, temp, 0, &result); |
a9fb0867 | 154 | assert_se(r > 0); |
d944dc95 | 155 | assert_se(path_equal(result, q)); |
b12d25a8 | 156 | result = mfree(result); |
d944dc95 | 157 | |
2a2fe6ed DM |
158 | /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */ |
159 | ||
160 | if (geteuid() == 0) { | |
161 | p = strjoina(temp, "/user"); | |
162 | assert_se(mkdir(p, 0755) >= 0); | |
163 | assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0); | |
164 | ||
165 | q = strjoina(temp, "/user/root"); | |
166 | assert_se(mkdir(q, 0755) >= 0); | |
167 | ||
168 | p = strjoina(q, "/link"); | |
169 | assert_se(symlink("/", p) >= 0); | |
170 | ||
171 | /* Fail when user-owned directories contain root-owned subdirectories. */ | |
172 | r = chase_symlinks(p, temp, CHASE_SAFE, &result); | |
173 | assert_se(r == -ENOLINK); | |
174 | result = mfree(result); | |
175 | ||
176 | /* Allow this when the user-owned directories are all in the "root". */ | |
177 | r = chase_symlinks(p, q, CHASE_SAFE, &result); | |
178 | assert_se(r > 0); | |
179 | result = mfree(result); | |
180 | } | |
181 | ||
df878e68 ZJS |
182 | /* Paths using . */ |
183 | ||
c4f4fce7 | 184 | r = chase_symlinks("/etc/./.././", NULL, 0, &result); |
a9fb0867 | 185 | assert_se(r > 0); |
d944dc95 | 186 | assert_se(path_equal(result, "/")); |
d944dc95 | 187 | result = mfree(result); |
b12d25a8 | 188 | |
c4f4fce7 | 189 | r = chase_symlinks("/etc/./.././", "/etc", 0, &result); |
a9fb0867 | 190 | assert_se(r > 0 && path_equal(result, "/etc")); |
d944dc95 | 191 | result = mfree(result); |
b12d25a8 | 192 | |
95f35ccc YW |
193 | r = chase_symlinks("/../.././//../../etc", NULL, 0, &result); |
194 | assert_se(r > 0); | |
195 | assert_se(streq(result, "/etc")); | |
196 | result = mfree(result); | |
197 | ||
198 | r = chase_symlinks("/../.././//../../test-chase.fsldajfl", NULL, CHASE_NONEXISTENT, &result); | |
199 | assert_se(r == 0); | |
200 | assert_se(streq(result, "/test-chase.fsldajfl")); | |
201 | result = mfree(result); | |
202 | ||
203 | r = chase_symlinks("/../.././//../../etc", "/", CHASE_PREFIX_ROOT, &result); | |
204 | assert_se(r > 0); | |
205 | assert_se(streq(result, "/etc")); | |
206 | result = mfree(result); | |
207 | ||
208 | r = chase_symlinks("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result); | |
209 | assert_se(r == 0); | |
210 | assert_se(streq(result, "/test-chase.fsldajfl")); | |
211 | result = mfree(result); | |
212 | ||
c4f4fce7 | 213 | r = chase_symlinks("/etc/machine-id/foo", NULL, 0, &result); |
d944dc95 | 214 | assert_se(r == -ENOTDIR); |
b12d25a8 | 215 | result = mfree(result); |
d944dc95 | 216 | |
df878e68 ZJS |
217 | /* Path that loops back to self */ |
218 | ||
d944dc95 LP |
219 | p = strjoina(temp, "/recursive-symlink"); |
220 | assert_se(symlink("recursive-symlink", p) >= 0); | |
c4f4fce7 | 221 | r = chase_symlinks(p, NULL, 0, &result); |
d944dc95 LP |
222 | assert_se(r == -ELOOP); |
223 | ||
a9fb0867 LP |
224 | /* Path which doesn't exist */ |
225 | ||
226 | p = strjoina(temp, "/idontexist"); | |
227 | r = chase_symlinks(p, NULL, 0, &result); | |
228 | assert_se(r == -ENOENT); | |
229 | ||
cb638b5e | 230 | r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); |
a9fb0867 LP |
231 | assert_se(r == 0); |
232 | assert_se(path_equal(result, p)); | |
233 | result = mfree(result); | |
234 | ||
235 | p = strjoina(temp, "/idontexist/meneither"); | |
236 | r = chase_symlinks(p, NULL, 0, &result); | |
237 | assert_se(r == -ENOENT); | |
238 | ||
cb638b5e | 239 | r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); |
a9fb0867 LP |
240 | assert_se(r == 0); |
241 | assert_se(path_equal(result, p)); | |
242 | result = mfree(result); | |
243 | ||
244 | /* Path which doesn't exist, but contains weird stuff */ | |
245 | ||
246 | p = strjoina(temp, "/idontexist/.."); | |
247 | r = chase_symlinks(p, NULL, 0, &result); | |
248 | assert_se(r == -ENOENT); | |
249 | ||
cb638b5e | 250 | r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result); |
a9fb0867 LP |
251 | assert_se(r == -ENOENT); |
252 | ||
877777d7 CCW |
253 | p = strjoina(temp, "/target"); |
254 | q = strjoina(temp, "/top"); | |
255 | assert_se(symlink(q, p) >= 0); | |
256 | p = strjoina(temp, "/target/idontexist"); | |
257 | r = chase_symlinks(p, NULL, 0, &result); | |
258 | assert_se(r == -ENOENT); | |
259 | ||
f14f1806 LP |
260 | if (geteuid() == 0) { |
261 | p = strjoina(temp, "/priv1"); | |
262 | assert_se(mkdir(p, 0755) >= 0); | |
263 | ||
264 | q = strjoina(p, "/priv2"); | |
265 | assert_se(mkdir(q, 0755) >= 0); | |
266 | ||
267 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0); | |
268 | ||
269 | assert_se(chown(q, UID_NOBODY, GID_NOBODY) >= 0); | |
270 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0); | |
271 | ||
272 | assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0); | |
273 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0); | |
274 | ||
275 | assert_se(chown(q, 0, 0) >= 0); | |
36c97dec | 276 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) == -ENOLINK); |
f14f1806 LP |
277 | |
278 | assert_se(rmdir(q) >= 0); | |
279 | assert_se(symlink("/etc/passwd", q) >= 0); | |
36c97dec | 280 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) == -ENOLINK); |
f14f1806 LP |
281 | |
282 | assert_se(chown(p, 0, 0) >= 0); | |
283 | assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL) >= 0); | |
284 | } | |
285 | ||
1ed34d75 LP |
286 | p = strjoina(temp, "/machine-id-test"); |
287 | assert_se(symlink("/usr/../etc/./machine-id", p) >= 0); | |
288 | ||
289 | pfd = chase_symlinks(p, NULL, CHASE_OPEN, NULL); | |
290 | if (pfd != -ENOENT) { | |
1ed34d75 LP |
291 | _cleanup_close_ int fd = -1; |
292 | sd_id128_t a, b; | |
293 | ||
294 | assert_se(pfd >= 0); | |
295 | ||
f2324783 | 296 | fd = fd_reopen(pfd, O_RDONLY|O_CLOEXEC); |
1ed34d75 | 297 | assert_se(fd >= 0); |
1ed34d75 LP |
298 | safe_close(pfd); |
299 | ||
300 | assert_se(id128_read_fd(fd, ID128_PLAIN, &a) >= 0); | |
301 | assert_se(sd_id128_get_machine(&b) >= 0); | |
302 | assert_se(sd_id128_equal(a, b)); | |
303 | } | |
304 | ||
1f56e4ce FB |
305 | /* Test CHASE_NOFOLLOW */ |
306 | ||
307 | p = strjoina(temp, "/target"); | |
308 | q = strjoina(temp, "/symlink"); | |
309 | assert_se(symlink(p, q) >= 0); | |
310 | pfd = chase_symlinks(q, NULL, CHASE_OPEN|CHASE_NOFOLLOW, &result); | |
311 | assert_se(pfd > 0); | |
312 | assert_se(path_equal(result, q)); | |
313 | assert_se(fstat(pfd, &st) >= 0); | |
314 | assert_se(S_ISLNK(st.st_mode)); | |
315 | result = mfree(result); | |
316 | ||
317 | /* s1 -> s2 -> nonexistent */ | |
318 | q = strjoina(temp, "/s1"); | |
319 | assert_se(symlink("s2", q) >= 0); | |
320 | p = strjoina(temp, "/s2"); | |
321 | assert_se(symlink("nonexistent", p) >= 0); | |
322 | pfd = chase_symlinks(q, NULL, CHASE_OPEN|CHASE_NOFOLLOW, &result); | |
323 | assert_se(pfd > 0); | |
324 | assert_se(path_equal(result, q)); | |
325 | assert_se(fstat(pfd, &st) >= 0); | |
326 | assert_se(S_ISLNK(st.st_mode)); | |
327 | result = mfree(result); | |
328 | ||
49eb3659 LP |
329 | /* Test CHASE_ONE */ |
330 | ||
331 | p = strjoina(temp, "/start"); | |
332 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
333 | assert_se(r == 0); | |
334 | p = strjoina(temp, "/top/dot/dotdota"); | |
335 | assert_se(streq(p, result)); | |
336 | result = mfree(result); | |
337 | ||
338 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
339 | assert_se(r == 0); | |
340 | p = strjoina(temp, "/top/./dotdota"); | |
341 | assert_se(streq(p, result)); | |
342 | result = mfree(result); | |
343 | ||
344 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
345 | assert_se(r == 0); | |
346 | p = strjoina(temp, "/top/../a"); | |
347 | assert_se(streq(p, result)); | |
348 | result = mfree(result); | |
349 | ||
350 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
351 | assert_se(r == 0); | |
352 | p = strjoina(temp, "/a"); | |
353 | assert_se(streq(p, result)); | |
354 | result = mfree(result); | |
355 | ||
356 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
357 | assert_se(r == 0); | |
358 | p = strjoina(temp, "/b"); | |
359 | assert_se(streq(p, result)); | |
360 | result = mfree(result); | |
361 | ||
362 | r = chase_symlinks(p, NULL, CHASE_STEP, &result); | |
363 | assert_se(r == 0); | |
364 | assert_se(streq("/usr", result)); | |
365 | result = mfree(result); | |
366 | ||
367 | r = chase_symlinks("/usr", NULL, CHASE_STEP, &result); | |
368 | assert_se(r > 0); | |
369 | assert_se(streq("/usr", result)); | |
370 | result = mfree(result); | |
371 | ||
27964854 | 372 | cleanup: |
d944dc95 LP |
373 | assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); |
374 | } | |
375 | ||
c270684a | 376 | static void test_unlink_noerrno(void) { |
27964854 | 377 | char *name; |
c270684a RC |
378 | int fd; |
379 | ||
27964854 ZJS |
380 | log_info("/* %s */", __func__); |
381 | ||
382 | name = strjoina(arg_test_dir ?: "/tmp", "/test-close_nointr.XXXXXX"); | |
646853bd | 383 | fd = mkostemp_safe(name); |
c270684a RC |
384 | assert_se(fd >= 0); |
385 | assert_se(close_nointr(fd) >= 0); | |
386 | ||
387 | { | |
388 | PROTECT_ERRNO; | |
840f606d | 389 | errno = 42; |
c270684a | 390 | assert_se(unlink_noerrno(name) >= 0); |
840f606d | 391 | assert_se(errno == 42); |
c270684a | 392 | assert_se(unlink_noerrno(name) < 0); |
840f606d | 393 | assert_se(errno == 42); |
c270684a RC |
394 | } |
395 | } | |
396 | ||
397 | static void test_readlink_and_make_absolute(void) { | |
27964854 ZJS |
398 | const char *tempdir, *name, *name2, *name_alias; |
399 | _cleanup_free_ char *r1 = NULL, *r2 = NULL, *pwd = NULL; | |
400 | ||
401 | log_info("/* %s */", __func__); | |
402 | ||
403 | tempdir = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute"); | |
404 | name = strjoina(tempdir, "/original"); | |
405 | name2 = "test-readlink_and_make_absolute/original"; | |
406 | name_alias = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute-alias"); | |
c270684a | 407 | |
37c1d5e9 | 408 | assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid(), MKDIR_WARN_MODE) >= 0); |
c270684a RC |
409 | assert_se(touch(name) >= 0); |
410 | ||
27964854 ZJS |
411 | if (symlink(name, name_alias) < 0) { |
412 | assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM)); | |
413 | log_tests_skipped_errno(errno, "symlink() not possible"); | |
414 | } else { | |
415 | assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0); | |
416 | assert_se(streq(r1, name)); | |
417 | assert_se(unlink(name_alias) >= 0); | |
c270684a | 418 | |
27964854 | 419 | assert_se(safe_getcwd(&pwd) >= 0); |
cd76d4c2 | 420 | |
27964854 ZJS |
421 | assert_se(chdir(tempdir) >= 0); |
422 | assert_se(symlink(name2, name_alias) >= 0); | |
423 | assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0); | |
424 | assert_se(streq(r2, name)); | |
425 | assert_se(unlink(name_alias) >= 0); | |
c270684a | 426 | |
27964854 ZJS |
427 | assert_se(chdir(pwd) >= 0); |
428 | } | |
cd76d4c2 | 429 | |
c270684a RC |
430 | assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0); |
431 | } | |
432 | ||
433 | static void test_get_files_in_directory(void) { | |
434 | _cleanup_strv_free_ char **l = NULL, **t = NULL; | |
435 | ||
27964854 | 436 | assert_se(get_files_in_directory(arg_test_dir ?: "/tmp", &l) >= 0); |
c270684a RC |
437 | assert_se(get_files_in_directory(".", &t) >= 0); |
438 | assert_se(get_files_in_directory(".", NULL) >= 0); | |
439 | } | |
440 | ||
34a8f081 | 441 | static void test_var_tmp(void) { |
4245eb50 | 442 | _cleanup_free_ char *tmpdir_backup = NULL, *temp_backup = NULL, *tmp_backup = NULL; |
992e8f22 | 443 | const char *tmp_dir = NULL, *t; |
34a8f081 | 444 | |
27964854 ZJS |
445 | log_info("/* %s */", __func__); |
446 | ||
992e8f22 LP |
447 | t = getenv("TMPDIR"); |
448 | if (t) { | |
449 | tmpdir_backup = strdup(t); | |
450 | assert_se(tmpdir_backup); | |
451 | } | |
34a8f081 | 452 | |
4245eb50 MAP |
453 | t = getenv("TEMP"); |
454 | if (t) { | |
455 | temp_backup = strdup(t); | |
456 | assert_se(temp_backup); | |
457 | } | |
458 | ||
459 | t = getenv("TMP"); | |
460 | if (t) { | |
461 | tmp_backup = strdup(t); | |
462 | assert_se(tmp_backup); | |
463 | } | |
464 | ||
85e55d14 YW |
465 | assert_se(unsetenv("TMPDIR") >= 0); |
466 | assert_se(unsetenv("TEMP") >= 0); | |
467 | assert_se(unsetenv("TMP") >= 0); | |
34a8f081 | 468 | |
992e8f22 LP |
469 | assert_se(var_tmp_dir(&tmp_dir) >= 0); |
470 | assert_se(streq(tmp_dir, "/var/tmp")); | |
34a8f081 | 471 | |
992e8f22 LP |
472 | assert_se(setenv("TMPDIR", "/tmp", true) >= 0); |
473 | assert_se(streq(getenv("TMPDIR"), "/tmp")); | |
34a8f081 | 474 | |
992e8f22 LP |
475 | assert_se(var_tmp_dir(&tmp_dir) >= 0); |
476 | assert_se(streq(tmp_dir, "/tmp")); | |
34a8f081 | 477 | |
992e8f22 LP |
478 | assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0); |
479 | assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88")); | |
34a8f081 | 480 | |
992e8f22 LP |
481 | assert_se(var_tmp_dir(&tmp_dir) >= 0); |
482 | assert_se(streq(tmp_dir, "/var/tmp")); | |
34a8f081 | 483 | |
992e8f22 LP |
484 | if (tmpdir_backup) { |
485 | assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0); | |
486 | assert_se(streq(getenv("TMPDIR"), tmpdir_backup)); | |
34a8f081 | 487 | } |
4245eb50 MAP |
488 | |
489 | if (temp_backup) { | |
490 | assert_se(setenv("TEMP", temp_backup, true) >= 0); | |
491 | assert_se(streq(getenv("TEMP"), temp_backup)); | |
492 | } | |
493 | ||
494 | if (tmp_backup) { | |
495 | assert_se(setenv("TMP", tmp_backup, true) >= 0); | |
496 | assert_se(streq(getenv("TMP"), tmp_backup)); | |
497 | } | |
34a8f081 OW |
498 | } |
499 | ||
49bfc877 | 500 | static void test_dot_or_dot_dot(void) { |
27964854 ZJS |
501 | log_info("/* %s */", __func__); |
502 | ||
49bfc877 LP |
503 | assert_se(!dot_or_dot_dot(NULL)); |
504 | assert_se(!dot_or_dot_dot("")); | |
505 | assert_se(!dot_or_dot_dot("xxx")); | |
506 | assert_se(dot_or_dot_dot(".")); | |
507 | assert_se(dot_or_dot_dot("..")); | |
508 | assert_se(!dot_or_dot_dot(".foo")); | |
509 | assert_se(!dot_or_dot_dot("..foo")); | |
510 | } | |
511 | ||
57a4359e LP |
512 | static void test_access_fd(void) { |
513 | _cleanup_(rmdir_and_freep) char *p = NULL; | |
514 | _cleanup_close_ int fd = -1; | |
27964854 | 515 | const char *a; |
57a4359e | 516 | |
27964854 ZJS |
517 | log_info("/* %s */", __func__); |
518 | ||
519 | a = strjoina(arg_test_dir ?: "/tmp", "/access-fd.XXXXXX"); | |
520 | assert_se(mkdtemp_malloc(a, &p) >= 0); | |
57a4359e LP |
521 | |
522 | fd = open(p, O_RDONLY|O_DIRECTORY|O_CLOEXEC); | |
523 | assert_se(fd >= 0); | |
524 | ||
525 | assert_se(access_fd(fd, R_OK) >= 0); | |
526 | assert_se(access_fd(fd, F_OK) >= 0); | |
527 | assert_se(access_fd(fd, W_OK) >= 0); | |
528 | ||
529 | assert_se(fchmod(fd, 0000) >= 0); | |
530 | ||
531 | assert_se(access_fd(fd, F_OK) >= 0); | |
532 | ||
533 | if (geteuid() == 0) { | |
534 | assert_se(access_fd(fd, R_OK) >= 0); | |
535 | assert_se(access_fd(fd, W_OK) >= 0); | |
536 | } else { | |
537 | assert_se(access_fd(fd, R_OK) == -EACCES); | |
538 | assert_se(access_fd(fd, W_OK) == -EACCES); | |
539 | } | |
540 | } | |
541 | ||
9e3fa6e8 LP |
542 | static void test_touch_file(void) { |
543 | uid_t test_uid, test_gid; | |
544 | _cleanup_(rm_rf_physical_and_freep) char *p = NULL; | |
545 | struct stat st; | |
546 | const char *a; | |
547 | usec_t test_mtime; | |
9590065f | 548 | int r; |
9e3fa6e8 | 549 | |
27964854 ZJS |
550 | log_info("/* %s */", __func__); |
551 | ||
9e3fa6e8 LP |
552 | test_uid = geteuid() == 0 ? 65534 : getuid(); |
553 | test_gid = geteuid() == 0 ? 65534 : getgid(); | |
554 | ||
555 | test_mtime = usec_sub_unsigned(now(CLOCK_REALTIME), USEC_PER_WEEK); | |
556 | ||
27964854 ZJS |
557 | a = strjoina(arg_test_dir ?: "/dev/shm", "/touch-file-XXXXXX"); |
558 | assert_se(mkdtemp_malloc(a, &p) >= 0); | |
9e3fa6e8 LP |
559 | |
560 | a = strjoina(p, "/regular"); | |
27964854 ZJS |
561 | r = touch_file(a, false, test_mtime, test_uid, test_gid, 0640); |
562 | if (r < 0) { | |
563 | assert_se(IN_SET(r, -EINVAL, -ENOSYS, -ENOTTY, -EPERM)); | |
564 | log_tests_skipped_errno(errno, "touch_file() not possible"); | |
565 | return; | |
566 | } | |
567 | ||
9e3fa6e8 LP |
568 | assert_se(lstat(a, &st) >= 0); |
569 | assert_se(st.st_uid == test_uid); | |
570 | assert_se(st.st_gid == test_gid); | |
571 | assert_se(S_ISREG(st.st_mode)); | |
572 | assert_se((st.st_mode & 0777) == 0640); | |
573 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
574 | ||
575 | a = strjoina(p, "/dir"); | |
576 | assert_se(mkdir(a, 0775) >= 0); | |
577 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); | |
578 | assert_se(lstat(a, &st) >= 0); | |
579 | assert_se(st.st_uid == test_uid); | |
580 | assert_se(st.st_gid == test_gid); | |
581 | assert_se(S_ISDIR(st.st_mode)); | |
582 | assert_se((st.st_mode & 0777) == 0640); | |
583 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
584 | ||
585 | a = strjoina(p, "/fifo"); | |
586 | assert_se(mkfifo(a, 0775) >= 0); | |
587 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); | |
588 | assert_se(lstat(a, &st) >= 0); | |
589 | assert_se(st.st_uid == test_uid); | |
590 | assert_se(st.st_gid == test_gid); | |
591 | assert_se(S_ISFIFO(st.st_mode)); | |
592 | assert_se((st.st_mode & 0777) == 0640); | |
593 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
594 | ||
595 | a = strjoina(p, "/sock"); | |
596 | assert_se(mknod(a, 0775 | S_IFSOCK, 0) >= 0); | |
597 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); | |
598 | assert_se(lstat(a, &st) >= 0); | |
599 | assert_se(st.st_uid == test_uid); | |
600 | assert_se(st.st_gid == test_gid); | |
601 | assert_se(S_ISSOCK(st.st_mode)); | |
602 | assert_se((st.st_mode & 0777) == 0640); | |
603 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
604 | ||
605 | if (geteuid() == 0) { | |
606 | a = strjoina(p, "/cdev"); | |
9590065f YW |
607 | r = mknod(a, 0775 | S_IFCHR, makedev(0, 0)); |
608 | if (r < 0 && errno == EPERM && detect_container() > 0) { | |
609 | log_notice("Running in unprivileged container? Skipping remaining tests in %s", __func__); | |
610 | return; | |
611 | } | |
612 | assert_se(r >= 0); | |
9e3fa6e8 LP |
613 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); |
614 | assert_se(lstat(a, &st) >= 0); | |
615 | assert_se(st.st_uid == test_uid); | |
616 | assert_se(st.st_gid == test_gid); | |
617 | assert_se(S_ISCHR(st.st_mode)); | |
618 | assert_se((st.st_mode & 0777) == 0640); | |
619 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
620 | ||
621 | a = strjoina(p, "/bdev"); | |
622 | assert_se(mknod(a, 0775 | S_IFBLK, makedev(0, 0)) >= 0); | |
623 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); | |
624 | assert_se(lstat(a, &st) >= 0); | |
625 | assert_se(st.st_uid == test_uid); | |
626 | assert_se(st.st_gid == test_gid); | |
627 | assert_se(S_ISBLK(st.st_mode)); | |
628 | assert_se((st.st_mode & 0777) == 0640); | |
629 | assert_se(timespec_load(&st.st_mtim) == test_mtime); | |
630 | } | |
631 | ||
632 | a = strjoina(p, "/lnk"); | |
633 | assert_se(symlink("target", a) >= 0); | |
634 | assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0); | |
635 | assert_se(lstat(a, &st) >= 0); | |
636 | assert_se(st.st_uid == test_uid); | |
637 | assert_se(st.st_gid == test_gid); | |
638 | assert_se(S_ISLNK(st.st_mode)); | |
9e3fa6e8 LP |
639 | assert_se(timespec_load(&st.st_mtim) == test_mtime); |
640 | } | |
641 | ||
43767d9d LP |
642 | static void test_unlinkat_deallocate(void) { |
643 | _cleanup_free_ char *p = NULL; | |
644 | _cleanup_close_ int fd = -1; | |
645 | struct stat st; | |
646 | ||
27964854 ZJS |
647 | log_info("/* %s */", __func__); |
648 | ||
649 | assert_se(tempfn_random_child(arg_test_dir, "unlink-deallocation", &p) >= 0); | |
43767d9d LP |
650 | |
651 | fd = open(p, O_WRONLY|O_CLOEXEC|O_CREAT|O_EXCL, 0600); | |
652 | assert_se(fd >= 0); | |
653 | ||
654 | assert_se(write(fd, "hallo\n", 6) == 6); | |
655 | ||
656 | assert_se(fstat(fd, &st) >= 0); | |
657 | assert_se(st.st_size == 6); | |
658 | assert_se(st.st_blocks > 0); | |
659 | assert_se(st.st_nlink == 1); | |
660 | ||
661 | assert_se(unlinkat_deallocate(AT_FDCWD, p, 0) >= 0); | |
662 | ||
663 | assert_se(fstat(fd, &st) >= 0); | |
27964854 ZJS |
664 | assert_se(IN_SET(st.st_size, 0, 6)); /* depending on whether hole punching worked the size will be 6 |
665 | (it worked) or 0 (we had to resort to truncation) */ | |
43767d9d LP |
666 | assert_se(st.st_blocks == 0); |
667 | assert_se(st.st_nlink == 0); | |
668 | } | |
669 | ||
11b29a96 LP |
670 | static void test_fsync_directory_of_file(void) { |
671 | _cleanup_close_ int fd = -1; | |
672 | ||
27964854 ZJS |
673 | log_info("/* %s */", __func__); |
674 | ||
675 | fd = open_tmpfile_unlinkable(arg_test_dir, O_RDWR); | |
11b29a96 LP |
676 | assert_se(fd >= 0); |
677 | ||
678 | assert_se(fsync_directory_of_file(fd) >= 0); | |
679 | } | |
680 | ||
4a5d7761 | 681 | static void test_rename_noreplace(void) { |
7158b4b3 | 682 | static const char* const table[] = { |
4a5d7761 LP |
683 | "/reg", |
684 | "/dir", | |
685 | "/fifo", | |
686 | "/socket", | |
687 | "/symlink", | |
688 | NULL | |
689 | }; | |
690 | ||
691 | _cleanup_(rm_rf_physical_and_freep) char *z = NULL; | |
27964854 | 692 | const char *j = NULL; |
4a5d7761 LP |
693 | char **a, **b; |
694 | ||
27964854 ZJS |
695 | log_info("/* %s */", __func__); |
696 | ||
697 | if (arg_test_dir) | |
698 | j = strjoina(arg_test_dir, "/testXXXXXX"); | |
7158b4b3 | 699 | assert_se(mkdtemp_malloc(j, &z) >= 0); |
4a5d7761 LP |
700 | |
701 | j = strjoina(z, table[0]); | |
702 | assert_se(touch(j) >= 0); | |
703 | ||
704 | j = strjoina(z, table[1]); | |
705 | assert_se(mkdir(j, 0777) >= 0); | |
706 | ||
707 | j = strjoina(z, table[2]); | |
708 | (void) mkfifo(j, 0777); | |
709 | ||
710 | j = strjoina(z, table[3]); | |
711 | (void) mknod(j, S_IFSOCK | 0777, 0); | |
712 | ||
713 | j = strjoina(z, table[4]); | |
714 | (void) symlink("foobar", j); | |
715 | ||
716 | STRV_FOREACH(a, (char**) table) { | |
717 | _cleanup_free_ char *x = NULL, *y = NULL; | |
718 | ||
719 | x = strjoin(z, *a); | |
720 | assert_se(x); | |
721 | ||
722 | if (access(x, F_OK) < 0) { | |
723 | assert_se(errno == ENOENT); | |
724 | continue; | |
725 | } | |
726 | ||
727 | STRV_FOREACH(b, (char**) table) { | |
b81b9d40 | 728 | _cleanup_free_ char *w = NULL; |
4a5d7761 | 729 | |
b81b9d40 YW |
730 | w = strjoin(w, *b); |
731 | assert_se(w); | |
732 | ||
733 | if (access(w, F_OK) < 0) { | |
4a5d7761 LP |
734 | assert_se(errno == ENOENT); |
735 | continue; | |
736 | } | |
737 | ||
b81b9d40 | 738 | assert_se(rename_noreplace(AT_FDCWD, w, AT_FDCWD, y) == -EEXIST); |
4a5d7761 LP |
739 | } |
740 | ||
741 | y = strjoin(z, "/somethingelse"); | |
742 | assert_se(y); | |
743 | ||
744 | assert_se(rename_noreplace(AT_FDCWD, x, AT_FDCWD, y) >= 0); | |
745 | assert_se(rename_noreplace(AT_FDCWD, y, AT_FDCWD, x) >= 0); | |
746 | } | |
747 | } | |
748 | ||
c1447be4 LP |
749 | static void test_chmod_and_chown(void) { |
750 | _cleanup_(rm_rf_physical_and_freep) char *d = NULL; | |
751 | _unused_ _cleanup_umask_ mode_t u = umask(0000); | |
752 | struct stat st; | |
753 | const char *p; | |
754 | ||
755 | if (geteuid() != 0) | |
756 | return; | |
757 | ||
758 | log_info("/* %s */", __func__); | |
759 | ||
760 | assert_se(mkdtemp_malloc(NULL, &d) >= 0); | |
761 | ||
762 | p = strjoina(d, "/reg"); | |
763 | assert_se(mknod(p, S_IFREG | 0123, 0) >= 0); | |
764 | ||
765 | assert_se(chmod_and_chown(p, S_IFREG | 0321, 1, 2) >= 0); | |
766 | assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL); | |
767 | ||
768 | assert_se(lstat(p, &st) >= 0); | |
769 | assert_se(S_ISREG(st.st_mode)); | |
770 | assert_se((st.st_mode & 07777) == 0321); | |
771 | ||
772 | p = strjoina(d, "/dir"); | |
773 | assert_se(mkdir(p, 0123) >= 0); | |
774 | ||
775 | assert_se(chmod_and_chown(p, S_IFDIR | 0321, 1, 2) >= 0); | |
776 | assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL); | |
777 | ||
778 | assert_se(lstat(p, &st) >= 0); | |
779 | assert_se(S_ISDIR(st.st_mode)); | |
780 | assert_se((st.st_mode & 07777) == 0321); | |
781 | ||
782 | p = strjoina(d, "/lnk"); | |
783 | assert_se(symlink("idontexist", p) >= 0); | |
784 | ||
785 | assert_se(chmod_and_chown(p, S_IFLNK | 0321, 1, 2) >= 0); | |
786 | assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL); | |
787 | assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL); | |
788 | ||
789 | assert_se(lstat(p, &st) >= 0); | |
790 | assert_se(S_ISLNK(st.st_mode)); | |
791 | } | |
792 | ||
c270684a | 793 | int main(int argc, char *argv[]) { |
27964854 ZJS |
794 | test_setup_logging(LOG_INFO); |
795 | ||
796 | arg_test_dir = argv[1]; | |
797 | ||
c270684a | 798 | test_unlink_noerrno(); |
c270684a | 799 | test_get_files_in_directory(); |
496c486f | 800 | test_readlink_and_make_absolute(); |
34a8f081 | 801 | test_var_tmp(); |
d944dc95 | 802 | test_chase_symlinks(); |
49bfc877 | 803 | test_dot_or_dot_dot(); |
57a4359e | 804 | test_access_fd(); |
9e3fa6e8 | 805 | test_touch_file(); |
43767d9d | 806 | test_unlinkat_deallocate(); |
11b29a96 | 807 | test_fsync_directory_of_file(); |
4a5d7761 | 808 | test_rename_noreplace(); |
c1447be4 | 809 | test_chmod_and_chown(); |
c270684a RC |
810 | |
811 | return 0; | |
812 | } |