1 /* SPDX-License-Identifier: LGPL-2.1+ */
5 #include "alloc-util.h"
8 #include "id128-util.h"
11 #include "path-util.h"
13 #include "stdio-util.h"
14 #include "string-util.h"
17 #include "tmpfile-util.h"
18 #include "umask-util.h"
19 #include "user-util.h"
23 static const char *arg_test_dir
= NULL
;
25 static void test_chase_symlinks(void) {
26 _cleanup_free_
char *result
= NULL
;
28 const char *top
, *p
, *pslash
, *q
, *qslash
;
32 log_info("/* %s */", __func__
);
34 temp
= strjoina(arg_test_dir
?: "/tmp", "/test-chase.XXXXXX");
35 assert_se(mkdtemp(temp
));
37 top
= strjoina(temp
, "/top");
38 assert_se(mkdir(top
, 0700) >= 0);
40 p
= strjoina(top
, "/dot");
41 if (symlink(".", p
) < 0) {
42 assert_se(IN_SET(errno
, EINVAL
, ENOSYS
, ENOTTY
, EPERM
));
43 log_tests_skipped_errno(errno
, "symlink() not possible");
47 p
= strjoina(top
, "/dotdot");
48 assert_se(symlink("..", p
) >= 0);
50 p
= strjoina(top
, "/dotdota");
51 assert_se(symlink("../a", p
) >= 0);
53 p
= strjoina(temp
, "/a");
54 assert_se(symlink("b", p
) >= 0);
56 p
= strjoina(temp
, "/b");
57 assert_se(symlink("/usr", p
) >= 0);
59 p
= strjoina(temp
, "/start");
60 assert_se(symlink("top/dot/dotdota", p
) >= 0);
62 /* Paths that use symlinks underneath the "root" */
64 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
66 assert_se(path_equal(result
, "/usr"));
67 result
= mfree(result
);
69 pslash
= strjoina(p
, "/");
70 r
= chase_symlinks(pslash
, NULL
, 0, &result
, NULL
);
72 assert_se(path_equal(result
, "/usr/"));
73 result
= mfree(result
);
75 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
76 assert_se(r
== -ENOENT
);
78 r
= chase_symlinks(pslash
, temp
, 0, &result
, NULL
);
79 assert_se(r
== -ENOENT
);
81 q
= strjoina(temp
, "/usr");
83 r
= chase_symlinks(p
, temp
, CHASE_NONEXISTENT
, &result
, NULL
);
85 assert_se(path_equal(result
, q
));
86 result
= mfree(result
);
88 qslash
= strjoina(q
, "/");
90 r
= chase_symlinks(pslash
, temp
, CHASE_NONEXISTENT
, &result
, NULL
);
92 assert_se(path_equal(result
, qslash
));
93 result
= mfree(result
);
95 assert_se(mkdir(q
, 0700) >= 0);
97 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
99 assert_se(path_equal(result
, q
));
100 result
= mfree(result
);
102 r
= chase_symlinks(pslash
, temp
, 0, &result
, NULL
);
104 assert_se(path_equal(result
, qslash
));
105 result
= mfree(result
);
107 p
= strjoina(temp
, "/slash");
108 assert_se(symlink("/", p
) >= 0);
110 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
112 assert_se(path_equal(result
, "/"));
113 result
= mfree(result
);
115 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
117 assert_se(path_equal(result
, temp
));
118 result
= mfree(result
);
120 /* Paths that would "escape" outside of the "root" */
122 p
= strjoina(temp
, "/6dots");
123 assert_se(symlink("../../..", p
) >= 0);
125 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
126 assert_se(r
> 0 && path_equal(result
, temp
));
127 result
= mfree(result
);
129 p
= strjoina(temp
, "/6dotsusr");
130 assert_se(symlink("../../../usr", p
) >= 0);
132 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
133 assert_se(r
> 0 && path_equal(result
, q
));
134 result
= mfree(result
);
136 p
= strjoina(temp
, "/top/8dotsusr");
137 assert_se(symlink("../../../../usr", p
) >= 0);
139 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
140 assert_se(r
> 0 && path_equal(result
, q
));
141 result
= mfree(result
);
143 /* Paths that contain repeated slashes */
145 p
= strjoina(temp
, "/slashslash");
146 assert_se(symlink("///usr///", p
) >= 0);
148 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
150 assert_se(path_equal(result
, "/usr"));
151 assert_se(streq(result
, "/usr")); /* we guarantee that we drop redundant slashes */
152 result
= mfree(result
);
154 r
= chase_symlinks(p
, temp
, 0, &result
, NULL
);
156 assert_se(path_equal(result
, q
));
157 result
= mfree(result
);
159 /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */
161 if (geteuid() == 0) {
162 p
= strjoina(temp
, "/user");
163 assert_se(mkdir(p
, 0755) >= 0);
164 assert_se(chown(p
, UID_NOBODY
, GID_NOBODY
) >= 0);
166 q
= strjoina(temp
, "/user/root");
167 assert_se(mkdir(q
, 0755) >= 0);
169 p
= strjoina(q
, "/link");
170 assert_se(symlink("/", p
) >= 0);
172 /* Fail when user-owned directories contain root-owned subdirectories. */
173 r
= chase_symlinks(p
, temp
, CHASE_SAFE
, &result
, NULL
);
174 assert_se(r
== -ENOLINK
);
175 result
= mfree(result
);
177 /* Allow this when the user-owned directories are all in the "root". */
178 r
= chase_symlinks(p
, q
, CHASE_SAFE
, &result
, NULL
);
180 result
= mfree(result
);
185 r
= chase_symlinks("/etc/./.././", NULL
, 0, &result
, NULL
);
187 assert_se(path_equal(result
, "/"));
188 result
= mfree(result
);
190 r
= chase_symlinks("/etc/./.././", "/etc", 0, &result
, NULL
);
191 assert_se(r
> 0 && path_equal(result
, "/etc"));
192 result
= mfree(result
);
194 r
= chase_symlinks("/../.././//../../etc", NULL
, 0, &result
, NULL
);
196 assert_se(streq(result
, "/etc"));
197 result
= mfree(result
);
199 r
= chase_symlinks("/../.././//../../test-chase.fsldajfl", NULL
, CHASE_NONEXISTENT
, &result
, NULL
);
201 assert_se(streq(result
, "/test-chase.fsldajfl"));
202 result
= mfree(result
);
204 r
= chase_symlinks("/../.././//../../etc", "/", CHASE_PREFIX_ROOT
, &result
, NULL
);
206 assert_se(streq(result
, "/etc"));
207 result
= mfree(result
);
209 r
= chase_symlinks("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT
|CHASE_NONEXISTENT
, &result
, NULL
);
211 assert_se(streq(result
, "/test-chase.fsldajfl"));
212 result
= mfree(result
);
214 r
= chase_symlinks("/etc/machine-id/foo", NULL
, 0, &result
, NULL
);
215 assert_se(r
== -ENOTDIR
);
216 result
= mfree(result
);
218 /* Path that loops back to self */
220 p
= strjoina(temp
, "/recursive-symlink");
221 assert_se(symlink("recursive-symlink", p
) >= 0);
222 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
223 assert_se(r
== -ELOOP
);
225 /* Path which doesn't exist */
227 p
= strjoina(temp
, "/idontexist");
228 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
229 assert_se(r
== -ENOENT
);
231 r
= chase_symlinks(p
, NULL
, CHASE_NONEXISTENT
, &result
, NULL
);
233 assert_se(path_equal(result
, p
));
234 result
= mfree(result
);
236 p
= strjoina(temp
, "/idontexist/meneither");
237 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
238 assert_se(r
== -ENOENT
);
240 r
= chase_symlinks(p
, NULL
, CHASE_NONEXISTENT
, &result
, NULL
);
242 assert_se(path_equal(result
, p
));
243 result
= mfree(result
);
245 /* Path which doesn't exist, but contains weird stuff */
247 p
= strjoina(temp
, "/idontexist/..");
248 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
249 assert_se(r
== -ENOENT
);
251 r
= chase_symlinks(p
, NULL
, CHASE_NONEXISTENT
, &result
, NULL
);
252 assert_se(r
== -ENOENT
);
254 p
= strjoina(temp
, "/target");
255 q
= strjoina(temp
, "/top");
256 assert_se(symlink(q
, p
) >= 0);
257 p
= strjoina(temp
, "/target/idontexist");
258 r
= chase_symlinks(p
, NULL
, 0, &result
, NULL
);
259 assert_se(r
== -ENOENT
);
261 if (geteuid() == 0) {
262 p
= strjoina(temp
, "/priv1");
263 assert_se(mkdir(p
, 0755) >= 0);
265 q
= strjoina(p
, "/priv2");
266 assert_se(mkdir(q
, 0755) >= 0);
268 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) >= 0);
270 assert_se(chown(q
, UID_NOBODY
, GID_NOBODY
) >= 0);
271 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) >= 0);
273 assert_se(chown(p
, UID_NOBODY
, GID_NOBODY
) >= 0);
274 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) >= 0);
276 assert_se(chown(q
, 0, 0) >= 0);
277 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) == -ENOLINK
);
279 assert_se(rmdir(q
) >= 0);
280 assert_se(symlink("/etc/passwd", q
) >= 0);
281 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) == -ENOLINK
);
283 assert_se(chown(p
, 0, 0) >= 0);
284 assert_se(chase_symlinks(q
, NULL
, CHASE_SAFE
, NULL
, NULL
) >= 0);
287 p
= strjoina(temp
, "/machine-id-test");
288 assert_se(symlink("/usr/../etc/./machine-id", p
) >= 0);
290 r
= chase_symlinks(p
, NULL
, 0, NULL
, &pfd
);
292 _cleanup_close_
int fd
= -1;
297 fd
= fd_reopen(pfd
, O_RDONLY
|O_CLOEXEC
);
301 assert_se(id128_read_fd(fd
, ID128_PLAIN
, &a
) >= 0);
302 assert_se(sd_id128_get_machine(&b
) >= 0);
303 assert_se(sd_id128_equal(a
, b
));
306 /* Test CHASE_NOFOLLOW */
308 p
= strjoina(temp
, "/target");
309 q
= strjoina(temp
, "/symlink");
310 assert_se(symlink(p
, q
) >= 0);
311 r
= chase_symlinks(q
, NULL
, CHASE_NOFOLLOW
, &result
, &pfd
);
314 assert_se(path_equal(result
, q
));
315 assert_se(fstat(pfd
, &st
) >= 0);
316 assert_se(S_ISLNK(st
.st_mode
));
317 result
= mfree(result
);
319 /* s1 -> s2 -> nonexistent */
320 q
= strjoina(temp
, "/s1");
321 assert_se(symlink("s2", q
) >= 0);
322 p
= strjoina(temp
, "/s2");
323 assert_se(symlink("nonexistent", p
) >= 0);
324 r
= chase_symlinks(q
, NULL
, CHASE_NOFOLLOW
, &result
, &pfd
);
327 assert_se(path_equal(result
, q
));
328 assert_se(fstat(pfd
, &st
) >= 0);
329 assert_se(S_ISLNK(st
.st_mode
));
330 result
= mfree(result
);
334 p
= strjoina(temp
, "/start");
335 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
337 p
= strjoina(temp
, "/top/dot/dotdota");
338 assert_se(streq(p
, result
));
339 result
= mfree(result
);
341 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
343 p
= strjoina(temp
, "/top/./dotdota");
344 assert_se(streq(p
, result
));
345 result
= mfree(result
);
347 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
349 p
= strjoina(temp
, "/top/../a");
350 assert_se(streq(p
, result
));
351 result
= mfree(result
);
353 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
355 p
= strjoina(temp
, "/a");
356 assert_se(streq(p
, result
));
357 result
= mfree(result
);
359 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
361 p
= strjoina(temp
, "/b");
362 assert_se(streq(p
, result
));
363 result
= mfree(result
);
365 r
= chase_symlinks(p
, NULL
, CHASE_STEP
, &result
, NULL
);
367 assert_se(streq("/usr", result
));
368 result
= mfree(result
);
370 r
= chase_symlinks("/usr", NULL
, CHASE_STEP
, &result
, NULL
);
372 assert_se(streq("/usr", result
));
373 result
= mfree(result
);
375 /* Make sure that symlinks in the "root" path are not resolved, but those below are */
376 p
= strjoina("/etc/..", temp
, "/self");
377 assert_se(symlink(".", p
) >= 0);
378 q
= strjoina(p
, "/top/dot/dotdota");
379 r
= chase_symlinks(q
, p
, 0, &result
, NULL
);
381 assert_se(path_equal(path_startswith(result
, p
), "usr"));
382 result
= mfree(result
);
385 assert_se(rm_rf(temp
, REMOVE_ROOT
|REMOVE_PHYSICAL
) >= 0);
388 static void test_unlink_noerrno(void) {
392 log_info("/* %s */", __func__
);
394 name
= strjoina(arg_test_dir
?: "/tmp", "/test-close_nointr.XXXXXX");
395 fd
= mkostemp_safe(name
);
397 assert_se(close_nointr(fd
) >= 0);
402 assert_se(unlink_noerrno(name
) >= 0);
403 assert_se(errno
== 42);
404 assert_se(unlink_noerrno(name
) < 0);
405 assert_se(errno
== 42);
409 static void test_readlink_and_make_absolute(void) {
410 const char *tempdir
, *name
, *name2
, *name_alias
;
411 _cleanup_free_
char *r1
= NULL
, *r2
= NULL
, *pwd
= NULL
;
413 log_info("/* %s */", __func__
);
415 tempdir
= strjoina(arg_test_dir
?: "/tmp", "/test-readlink_and_make_absolute");
416 name
= strjoina(tempdir
, "/original");
417 name2
= "test-readlink_and_make_absolute/original";
418 name_alias
= strjoina(arg_test_dir
?: "/tmp", "/test-readlink_and_make_absolute-alias");
420 assert_se(mkdir_safe(tempdir
, 0755, getuid(), getgid(), MKDIR_WARN_MODE
) >= 0);
421 assert_se(touch(name
) >= 0);
423 if (symlink(name
, name_alias
) < 0) {
424 assert_se(IN_SET(errno
, EINVAL
, ENOSYS
, ENOTTY
, EPERM
));
425 log_tests_skipped_errno(errno
, "symlink() not possible");
427 assert_se(readlink_and_make_absolute(name_alias
, &r1
) >= 0);
428 assert_se(streq(r1
, name
));
429 assert_se(unlink(name_alias
) >= 0);
431 assert_se(safe_getcwd(&pwd
) >= 0);
433 assert_se(chdir(tempdir
) >= 0);
434 assert_se(symlink(name2
, name_alias
) >= 0);
435 assert_se(readlink_and_make_absolute(name_alias
, &r2
) >= 0);
436 assert_se(streq(r2
, name
));
437 assert_se(unlink(name_alias
) >= 0);
439 assert_se(chdir(pwd
) >= 0);
442 assert_se(rm_rf(tempdir
, REMOVE_ROOT
|REMOVE_PHYSICAL
) >= 0);
445 static void test_get_files_in_directory(void) {
446 _cleanup_strv_free_
char **l
= NULL
, **t
= NULL
;
448 assert_se(get_files_in_directory(arg_test_dir
?: "/tmp", &l
) >= 0);
449 assert_se(get_files_in_directory(".", &t
) >= 0);
450 assert_se(get_files_in_directory(".", NULL
) >= 0);
453 static void test_var_tmp(void) {
454 _cleanup_free_
char *tmpdir_backup
= NULL
, *temp_backup
= NULL
, *tmp_backup
= NULL
;
455 const char *tmp_dir
= NULL
, *t
;
457 log_info("/* %s */", __func__
);
459 t
= getenv("TMPDIR");
461 tmpdir_backup
= strdup(t
);
462 assert_se(tmpdir_backup
);
467 temp_backup
= strdup(t
);
468 assert_se(temp_backup
);
473 tmp_backup
= strdup(t
);
474 assert_se(tmp_backup
);
477 assert_se(unsetenv("TMPDIR") >= 0);
478 assert_se(unsetenv("TEMP") >= 0);
479 assert_se(unsetenv("TMP") >= 0);
481 assert_se(var_tmp_dir(&tmp_dir
) >= 0);
482 assert_se(streq(tmp_dir
, "/var/tmp"));
484 assert_se(setenv("TMPDIR", "/tmp", true) >= 0);
485 assert_se(streq(getenv("TMPDIR"), "/tmp"));
487 assert_se(var_tmp_dir(&tmp_dir
) >= 0);
488 assert_se(streq(tmp_dir
, "/tmp"));
490 assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0);
491 assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88"));
493 assert_se(var_tmp_dir(&tmp_dir
) >= 0);
494 assert_se(streq(tmp_dir
, "/var/tmp"));
497 assert_se(setenv("TMPDIR", tmpdir_backup
, true) >= 0);
498 assert_se(streq(getenv("TMPDIR"), tmpdir_backup
));
502 assert_se(setenv("TEMP", temp_backup
, true) >= 0);
503 assert_se(streq(getenv("TEMP"), temp_backup
));
507 assert_se(setenv("TMP", tmp_backup
, true) >= 0);
508 assert_se(streq(getenv("TMP"), tmp_backup
));
512 static void test_dot_or_dot_dot(void) {
513 log_info("/* %s */", __func__
);
515 assert_se(!dot_or_dot_dot(NULL
));
516 assert_se(!dot_or_dot_dot(""));
517 assert_se(!dot_or_dot_dot("xxx"));
518 assert_se(dot_or_dot_dot("."));
519 assert_se(dot_or_dot_dot(".."));
520 assert_se(!dot_or_dot_dot(".foo"));
521 assert_se(!dot_or_dot_dot("..foo"));
524 static void test_access_fd(void) {
525 _cleanup_(rmdir_and_freep
) char *p
= NULL
;
526 _cleanup_close_
int fd
= -1;
529 log_info("/* %s */", __func__
);
531 a
= strjoina(arg_test_dir
?: "/tmp", "/access-fd.XXXXXX");
532 assert_se(mkdtemp_malloc(a
, &p
) >= 0);
534 fd
= open(p
, O_RDONLY
|O_DIRECTORY
|O_CLOEXEC
);
537 assert_se(access_fd(fd
, R_OK
) >= 0);
538 assert_se(access_fd(fd
, F_OK
) >= 0);
539 assert_se(access_fd(fd
, W_OK
) >= 0);
541 assert_se(fchmod(fd
, 0000) >= 0);
543 assert_se(access_fd(fd
, F_OK
) >= 0);
545 if (geteuid() == 0) {
546 assert_se(access_fd(fd
, R_OK
) >= 0);
547 assert_se(access_fd(fd
, W_OK
) >= 0);
549 assert_se(access_fd(fd
, R_OK
) == -EACCES
);
550 assert_se(access_fd(fd
, W_OK
) == -EACCES
);
554 static void test_touch_file(void) {
555 uid_t test_uid
, test_gid
;
556 _cleanup_(rm_rf_physical_and_freep
) char *p
= NULL
;
562 log_info("/* %s */", __func__
);
564 test_uid
= geteuid() == 0 ? 65534 : getuid();
565 test_gid
= geteuid() == 0 ? 65534 : getgid();
567 test_mtime
= usec_sub_unsigned(now(CLOCK_REALTIME
), USEC_PER_WEEK
);
569 a
= strjoina(arg_test_dir
?: "/dev/shm", "/touch-file-XXXXXX");
570 assert_se(mkdtemp_malloc(a
, &p
) >= 0);
572 a
= strjoina(p
, "/regular");
573 r
= touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640);
575 assert_se(IN_SET(r
, -EINVAL
, -ENOSYS
, -ENOTTY
, -EPERM
));
576 log_tests_skipped_errno(errno
, "touch_file() not possible");
580 assert_se(lstat(a
, &st
) >= 0);
581 assert_se(st
.st_uid
== test_uid
);
582 assert_se(st
.st_gid
== test_gid
);
583 assert_se(S_ISREG(st
.st_mode
));
584 assert_se((st
.st_mode
& 0777) == 0640);
585 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
587 a
= strjoina(p
, "/dir");
588 assert_se(mkdir(a
, 0775) >= 0);
589 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
590 assert_se(lstat(a
, &st
) >= 0);
591 assert_se(st
.st_uid
== test_uid
);
592 assert_se(st
.st_gid
== test_gid
);
593 assert_se(S_ISDIR(st
.st_mode
));
594 assert_se((st
.st_mode
& 0777) == 0640);
595 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
597 a
= strjoina(p
, "/fifo");
598 assert_se(mkfifo(a
, 0775) >= 0);
599 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
600 assert_se(lstat(a
, &st
) >= 0);
601 assert_se(st
.st_uid
== test_uid
);
602 assert_se(st
.st_gid
== test_gid
);
603 assert_se(S_ISFIFO(st
.st_mode
));
604 assert_se((st
.st_mode
& 0777) == 0640);
605 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
607 a
= strjoina(p
, "/sock");
608 assert_se(mknod(a
, 0775 | S_IFSOCK
, 0) >= 0);
609 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
610 assert_se(lstat(a
, &st
) >= 0);
611 assert_se(st
.st_uid
== test_uid
);
612 assert_se(st
.st_gid
== test_gid
);
613 assert_se(S_ISSOCK(st
.st_mode
));
614 assert_se((st
.st_mode
& 0777) == 0640);
615 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
617 if (geteuid() == 0) {
618 a
= strjoina(p
, "/cdev");
619 r
= mknod(a
, 0775 | S_IFCHR
, makedev(0, 0));
620 if (r
< 0 && errno
== EPERM
&& detect_container() > 0) {
621 log_notice("Running in unprivileged container? Skipping remaining tests in %s", __func__
);
625 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
626 assert_se(lstat(a
, &st
) >= 0);
627 assert_se(st
.st_uid
== test_uid
);
628 assert_se(st
.st_gid
== test_gid
);
629 assert_se(S_ISCHR(st
.st_mode
));
630 assert_se((st
.st_mode
& 0777) == 0640);
631 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
633 a
= strjoina(p
, "/bdev");
634 assert_se(mknod(a
, 0775 | S_IFBLK
, makedev(0, 0)) >= 0);
635 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
636 assert_se(lstat(a
, &st
) >= 0);
637 assert_se(st
.st_uid
== test_uid
);
638 assert_se(st
.st_gid
== test_gid
);
639 assert_se(S_ISBLK(st
.st_mode
));
640 assert_se((st
.st_mode
& 0777) == 0640);
641 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
644 a
= strjoina(p
, "/lnk");
645 assert_se(symlink("target", a
) >= 0);
646 assert_se(touch_file(a
, false, test_mtime
, test_uid
, test_gid
, 0640) >= 0);
647 assert_se(lstat(a
, &st
) >= 0);
648 assert_se(st
.st_uid
== test_uid
);
649 assert_se(st
.st_gid
== test_gid
);
650 assert_se(S_ISLNK(st
.st_mode
));
651 assert_se(timespec_load(&st
.st_mtim
) == test_mtime
);
654 static void test_unlinkat_deallocate(void) {
655 _cleanup_free_
char *p
= NULL
;
656 _cleanup_close_
int fd
= -1;
659 log_info("/* %s */", __func__
);
661 assert_se(tempfn_random_child(arg_test_dir
, "unlink-deallocation", &p
) >= 0);
663 fd
= open(p
, O_WRONLY
|O_CLOEXEC
|O_CREAT
|O_EXCL
, 0600);
666 assert_se(write(fd
, "hallo\n", 6) == 6);
668 assert_se(fstat(fd
, &st
) >= 0);
669 assert_se(st
.st_size
== 6);
670 assert_se(st
.st_blocks
> 0);
671 assert_se(st
.st_nlink
== 1);
673 assert_se(unlinkat_deallocate(AT_FDCWD
, p
, UNLINK_ERASE
) >= 0);
675 assert_se(fstat(fd
, &st
) >= 0);
676 assert_se(IN_SET(st
.st_size
, 0, 6)); /* depending on whether hole punching worked the size will be 6
677 (it worked) or 0 (we had to resort to truncation) */
678 assert_se(st
.st_blocks
== 0);
679 assert_se(st
.st_nlink
== 0);
682 static void test_fsync_directory_of_file(void) {
683 _cleanup_close_
int fd
= -1;
685 log_info("/* %s */", __func__
);
687 fd
= open_tmpfile_unlinkable(arg_test_dir
, O_RDWR
);
690 assert_se(fsync_directory_of_file(fd
) >= 0);
693 static void test_rename_noreplace(void) {
694 static const char* const table
[] = {
703 _cleanup_(rm_rf_physical_and_freep
) char *z
= NULL
;
704 const char *j
= NULL
;
707 log_info("/* %s */", __func__
);
710 j
= strjoina(arg_test_dir
, "/testXXXXXX");
711 assert_se(mkdtemp_malloc(j
, &z
) >= 0);
713 j
= strjoina(z
, table
[0]);
714 assert_se(touch(j
) >= 0);
716 j
= strjoina(z
, table
[1]);
717 assert_se(mkdir(j
, 0777) >= 0);
719 j
= strjoina(z
, table
[2]);
720 (void) mkfifo(j
, 0777);
722 j
= strjoina(z
, table
[3]);
723 (void) mknod(j
, S_IFSOCK
| 0777, 0);
725 j
= strjoina(z
, table
[4]);
726 (void) symlink("foobar", j
);
728 STRV_FOREACH(a
, (char**) table
) {
729 _cleanup_free_
char *x
= NULL
, *y
= NULL
;
734 if (access(x
, F_OK
) < 0) {
735 assert_se(errno
== ENOENT
);
739 STRV_FOREACH(b
, (char**) table
) {
740 _cleanup_free_
char *w
= NULL
;
745 if (access(w
, F_OK
) < 0) {
746 assert_se(errno
== ENOENT
);
750 assert_se(rename_noreplace(AT_FDCWD
, x
, AT_FDCWD
, w
) == -EEXIST
);
753 y
= strjoin(z
, "/somethingelse");
756 assert_se(rename_noreplace(AT_FDCWD
, x
, AT_FDCWD
, y
) >= 0);
757 assert_se(rename_noreplace(AT_FDCWD
, y
, AT_FDCWD
, x
) >= 0);
761 static void test_chmod_and_chown(void) {
762 _cleanup_(rm_rf_physical_and_freep
) char *d
= NULL
;
763 _unused_ _cleanup_umask_ mode_t u
= umask(0000);
770 log_info("/* %s */", __func__
);
772 assert_se(mkdtemp_malloc(NULL
, &d
) >= 0);
774 p
= strjoina(d
, "/reg");
775 assert_se(mknod(p
, S_IFREG
| 0123, 0) >= 0);
777 assert_se(chmod_and_chown(p
, S_IFREG
| 0321, 1, 2) >= 0);
778 assert_se(chmod_and_chown(p
, S_IFDIR
| 0555, 3, 4) == -EINVAL
);
780 assert_se(lstat(p
, &st
) >= 0);
781 assert_se(S_ISREG(st
.st_mode
));
782 assert_se((st
.st_mode
& 07777) == 0321);
784 p
= strjoina(d
, "/dir");
785 assert_se(mkdir(p
, 0123) >= 0);
787 assert_se(chmod_and_chown(p
, S_IFDIR
| 0321, 1, 2) >= 0);
788 assert_se(chmod_and_chown(p
, S_IFREG
| 0555, 3, 4) == -EINVAL
);
790 assert_se(lstat(p
, &st
) >= 0);
791 assert_se(S_ISDIR(st
.st_mode
));
792 assert_se((st
.st_mode
& 07777) == 0321);
794 p
= strjoina(d
, "/lnk");
795 assert_se(symlink("idontexist", p
) >= 0);
797 assert_se(chmod_and_chown(p
, S_IFLNK
| 0321, 1, 2) >= 0);
798 assert_se(chmod_and_chown(p
, S_IFREG
| 0555, 3, 4) == -EINVAL
);
799 assert_se(chmod_and_chown(p
, S_IFDIR
| 0555, 3, 4) == -EINVAL
);
801 assert_se(lstat(p
, &st
) >= 0);
802 assert_se(S_ISLNK(st
.st_mode
));
805 static void test_chmod_and_chown_unsafe(void) {
806 _cleanup_(rm_rf_physical_and_freep
) char *d
= NULL
;
807 _unused_ _cleanup_umask_ mode_t u
= umask(0000);
814 log_info("/* %s */", __func__
);
816 assert_se(mkdtemp_malloc(NULL
, &d
) >= 0);
818 p
= strjoina(d
, "/reg");
819 assert_se(mknod(p
, S_IFREG
| 0123, 0) >= 0);
821 assert_se(chmod_and_chown_unsafe(p
, S_IFREG
| 0321, 1, 2) >= 0);
822 assert_se(chmod_and_chown_unsafe(p
, S_IFDIR
| 0555, 3, 4) == -EINVAL
);
824 assert_se(lstat(p
, &st
) >= 0);
825 assert_se(S_ISREG(st
.st_mode
));
826 assert_se((st
.st_mode
& 07777) == 0321);
828 p
= strjoina(d
, "/dir");
829 assert_se(mkdir(p
, 0123) >= 0);
831 assert_se(chmod_and_chown_unsafe(p
, S_IFDIR
| 0321, 1, 2) >= 0);
832 assert_se(chmod_and_chown_unsafe(p
, S_IFREG
| 0555, 3, 4) == -EINVAL
);
834 assert_se(lstat(p
, &st
) >= 0);
835 assert_se(S_ISDIR(st
.st_mode
));
836 assert_se((st
.st_mode
& 07777) == 0321);
838 p
= strjoina(d
, "/lnk");
839 assert_se(symlink("idontexist", p
) >= 0);
841 assert_se(chmod_and_chown_unsafe(p
, S_IFLNK
| 0321, 1, 2) >= 0);
842 assert_se(chmod_and_chown_unsafe(p
, S_IFREG
| 0555, 3, 4) == -EINVAL
);
843 assert_se(chmod_and_chown_unsafe(p
, S_IFDIR
| 0555, 3, 4) == -EINVAL
);
845 assert_se(lstat(p
, &st
) >= 0);
846 assert_se(S_ISLNK(st
.st_mode
));
849 static void test_path_is_encrypted_one(const char *p
, int expect
) {
852 r
= path_is_encrypted(p
);
853 if (r
== -ENOENT
) /* This might fail, if btrfs is used and we run in a container. In that case we
854 * cannot resolve the device node paths that BTRFS_IOC_DEV_INFO returns, because
855 * the device nodes are unlikely to exist in the container. But if we can't stat()
856 * them we cannot determine the dev_t of them, and thus cannot figure out if they
857 * are enrypted. Hence let's just ignore ENOENT here. */
861 log_info("%s encrypted: %s", p
, yes_no(r
));
863 assert_se(expect
< 0 || ((r
> 0) == (expect
> 0)));
866 static void test_path_is_encrypted(void) {
867 int booted
= sd_booted(); /* If this is run in build environments such as koji, /dev might be a
868 * reguar fs. Don't assume too much if not running under systemd. */
870 log_info("/* %s (sd_booted=%d)*/", __func__
, booted
);
872 test_path_is_encrypted_one("/home", -1);
873 test_path_is_encrypted_one("/var", -1);
874 test_path_is_encrypted_one("/", -1);
875 test_path_is_encrypted_one("/proc", false);
876 test_path_is_encrypted_one("/sys", false);
877 test_path_is_encrypted_one("/dev", booted
> 0 ? false : -1);
880 int main(int argc
, char *argv
[]) {
881 test_setup_logging(LOG_INFO
);
883 arg_test_dir
= argv
[1];
885 test_chase_symlinks();
886 test_unlink_noerrno();
887 test_readlink_and_make_absolute();
888 test_get_files_in_directory();
890 test_dot_or_dot_dot();
893 test_unlinkat_deallocate();
894 test_fsync_directory_of_file();
895 test_rename_noreplace();
896 test_chmod_and_chown();
897 test_chmod_and_chown_unsafe();
898 test_path_is_encrypted();