]> git.proxmox.com Git - systemd.git/blame - src/test/test-fs-util.c
projects / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 250.4
[systemd.git] / src / test / test-fs-util.c
CommitLineData
a032b68d 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
aa27b158
MP		 2
3#include <unistd.h>
4
5#include "alloc-util.h"
ea0999c9 6#include "chase-symlinks.h"
3a6ce677 7#include "copy.h"
aa27b158 8#include "fd-util.h"
3a6ce677 9#include "fileio.h"
aa27b158 10#include "fs-util.h"
1d42b86d 11#include "id128-util.h"
aa27b158
MP		 12#include "macro.h"
13#include "mkdir.h"
8a584da2 14#include "path-util.h"
3a6ce677 15#include "random-util.h"
aa27b158 16#include "rm-rf.h"
1d42b86d 17#include "stdio-util.h"
aa27b158
MP		 18#include "string-util.h"
19#include "strv.h"
ea0999c9 20#include "sync-util.h"
6e866b33
MB		 21#include "tests.h"
22#include "tmpfile-util.h"
f2dec872 23#include "umask-util.h"
1d42b86d 24#include "user-util.h"
aa27b158 25#include "util.h"
6e866b33
MB		 26#include "virt.h"
27
28static const char *arg_test_dir = NULL;
aa27b158 29
ea0999c9 30TEST(chase_symlinks) {
8a584da2 31 _cleanup_free_ char *result = NULL;
9cde670f 32 _cleanup_close_ int pfd = -1;
6e866b33 33 char *temp;
52ad194e 34 const char *top, *p, *pslash, *q, *qslash;
6e866b33 35 struct stat st;
9cde670f 36 int r;
8a584da2 37
6e866b33 38 temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX");
8a584da2
MP		 39 assert_se(mkdtemp(temp));
40
41 top = strjoina(temp, "/top");
42 assert_se(mkdir(top, 0700) >= 0);
43
44 p = strjoina(top, "/dot");
6e866b33
MB		 45 if (symlink(".", p) < 0) {
46 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
47 log_tests_skipped_errno(errno, "symlink() not possible");
48 goto cleanup;
49 };
8a584da2
MP		 50
51 p = strjoina(top, "/dotdot");
52 assert_se(symlink("..", p) >= 0);
53
54 p = strjoina(top, "/dotdota");
55 assert_se(symlink("../a", p) >= 0);
56
57 p = strjoina(temp, "/a");
58 assert_se(symlink("b", p) >= 0);
59
60 p = strjoina(temp, "/b");
61 assert_se(symlink("/usr", p) >= 0);
62
63 p = strjoina(temp, "/start");
64 assert_se(symlink("top/dot/dotdota", p) >= 0);
65
2897b343
MP		 66 /* Paths that use symlinks underneath the "root" */
67
e1f67bc7 68 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343 69 assert_se(r > 0);
8a584da2 70 assert_se(path_equal(result, "/usr"));
52ad194e 71 result = mfree(result);
8a584da2 72
52ad194e 73 pslash = strjoina(p, "/");
e1f67bc7 74 r = chase_symlinks(pslash, NULL, 0, &result, NULL);
52ad194e
MB		 75 assert_se(r > 0);
76 assert_se(path_equal(result, "/usr/"));
8a584da2 77 result = mfree(result);
52ad194e 78
e1f67bc7 79 r = chase_symlinks(p, temp, 0, &result, NULL);
8a584da2
MP		 80 assert_se(r == -ENOENT);
81
e1f67bc7 82 r = chase_symlinks(pslash, temp, 0, &result, NULL);
52ad194e
MB		 83 assert_se(r == -ENOENT);
84
8a584da2 85 q = strjoina(temp, "/usr");
2897b343 86
e1f67bc7 87 r = chase_symlinks(p, temp, CHASE_NONEXISTENT, &result, NULL);
2897b343
MP		 88 assert_se(r == 0);
89 assert_se(path_equal(result, q));
52ad194e 90 result = mfree(result);
2897b343 91
52ad194e 92 qslash = strjoina(q, "/");
8a584da2 93
e1f67bc7 94 r = chase_symlinks(pslash, temp, CHASE_NONEXISTENT, &result, NULL);
52ad194e
MB		 95 assert_se(r == 0);
96 assert_se(path_equal(result, qslash));
2897b343 97 result = mfree(result);
52ad194e
MB		 98
99 assert_se(mkdir(q, 0700) >= 0);
100
e1f67bc7 101 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 102 assert_se(r > 0);
8a584da2 103 assert_se(path_equal(result, q));
52ad194e
MB		 104 result = mfree(result);
105
e1f67bc7 106 r = chase_symlinks(pslash, temp, 0, &result, NULL);
52ad194e
MB		 107 assert_se(r > 0);
108 assert_se(path_equal(result, qslash));
109 result = mfree(result);
8a584da2
MP		 110
111 p = strjoina(temp, "/slash");
112 assert_se(symlink("/", p) >= 0);
113
e1f67bc7 114 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343 115 assert_se(r > 0);
8a584da2 116 assert_se(path_equal(result, "/"));
8a584da2 117 result = mfree(result);
52ad194e 118
e1f67bc7 119 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 120 assert_se(r > 0);
8a584da2 121 assert_se(path_equal(result, temp));
52ad194e 122 result = mfree(result);
8a584da2 123
2897b343
MP		 124 /* Paths that would "escape" outside of the "root" */
125
126 p = strjoina(temp, "/6dots");
127 assert_se(symlink("../../..", p) >= 0);
128
e1f67bc7 129 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 130 assert_se(r > 0 && path_equal(result, temp));
52ad194e 131 result = mfree(result);
2897b343
MP		 132
133 p = strjoina(temp, "/6dotsusr");
134 assert_se(symlink("../../../usr", p) >= 0);
135
e1f67bc7 136 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 137 assert_se(r > 0 && path_equal(result, q));
52ad194e 138 result = mfree(result);
2897b343
MP		 139
140 p = strjoina(temp, "/top/8dotsusr");
141 assert_se(symlink("../../../../usr", p) >= 0);
142
e1f67bc7 143 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 144 assert_se(r > 0 && path_equal(result, q));
52ad194e 145 result = mfree(result);
2897b343
MP		 146
147 /* Paths that contain repeated slashes */
148
8a584da2
MP		 149 p = strjoina(temp, "/slashslash");
150 assert_se(symlink("///usr///", p) >= 0);
151
e1f67bc7 152 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343 153 assert_se(r > 0);
8a584da2 154 assert_se(path_equal(result, "/usr"));
46cdbd49 155 assert_se(streq(result, "/usr")); /* we guarantee that we drop redundant slashes */
8a584da2 156 result = mfree(result);
52ad194e 157
e1f67bc7 158 r = chase_symlinks(p, temp, 0, &result, NULL);
2897b343 159 assert_se(r > 0);
8a584da2 160 assert_se(path_equal(result, q));
52ad194e 161 result = mfree(result);
8a584da2 162
bb4f798a
MB		 163 /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */
164
165 if (geteuid() == 0) {
166 p = strjoina(temp, "/user");
167 assert_se(mkdir(p, 0755) >= 0);
168 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
169
170 q = strjoina(temp, "/user/root");
171 assert_se(mkdir(q, 0755) >= 0);
172
173 p = strjoina(q, "/link");
174 assert_se(symlink("/", p) >= 0);
175
176 /* Fail when user-owned directories contain root-owned subdirectories. */
e1f67bc7 177 r = chase_symlinks(p, temp, CHASE_SAFE, &result, NULL);
bb4f798a
MB		 178 assert_se(r == -ENOLINK);
179 result = mfree(result);
180
181 /* Allow this when the user-owned directories are all in the "root". */
e1f67bc7 182 r = chase_symlinks(p, q, CHASE_SAFE, &result, NULL);
bb4f798a
MB		 183 assert_se(r > 0);
184 result = mfree(result);
185 }
186
2897b343
MP		 187 /* Paths using . */
188
e1f67bc7 189 r = chase_symlinks("/etc/./.././", NULL, 0, &result, NULL);
2897b343 190 assert_se(r > 0);
8a584da2 191 assert_se(path_equal(result, "/"));
8a584da2 192 result = mfree(result);
52ad194e 193
e1f67bc7 194 r = chase_symlinks("/etc/./.././", "/etc", 0, &result, NULL);
2897b343 195 assert_se(r > 0 && path_equal(result, "/etc"));
52ad194e 196 result = mfree(result);
8a584da2 197
e1f67bc7 198 r = chase_symlinks("/../.././//../../etc", NULL, 0, &result, NULL);
52ad194e
MB		 199 assert_se(r > 0);
200 assert_se(streq(result, "/etc"));
201 result = mfree(result);
202
e1f67bc7 203 r = chase_symlinks("/../.././//../../test-chase.fsldajfl", NULL, CHASE_NONEXISTENT, &result, NULL);
52ad194e
MB		 204 assert_se(r == 0);
205 assert_se(streq(result, "/test-chase.fsldajfl"));
8a584da2 206 result = mfree(result);
52ad194e 207
e1f67bc7 208 r = chase_symlinks("/../.././//../../etc", "/", CHASE_PREFIX_ROOT, &result, NULL);
52ad194e
MB		 209 assert_se(r > 0);
210 assert_se(streq(result, "/etc"));
211 result = mfree(result);
212
e1f67bc7 213 r = chase_symlinks("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result, NULL);
52ad194e
MB		 214 assert_se(r == 0);
215 assert_se(streq(result, "/test-chase.fsldajfl"));
216 result = mfree(result);
217
e1f67bc7 218 r = chase_symlinks("/etc/machine-id/foo", NULL, 0, &result, NULL);
8a584da2 219 assert_se(r == -ENOTDIR);
52ad194e 220 result = mfree(result);
8a584da2 221
2897b343
MP		 222 /* Path that loops back to self */
223
8a584da2
MP		 224 p = strjoina(temp, "/recursive-symlink");
225 assert_se(symlink("recursive-symlink", p) >= 0);
e1f67bc7 226 r = chase_symlinks(p, NULL, 0, &result, NULL);
8a584da2
MP		 227 assert_se(r == -ELOOP);
228
2897b343
MP		 229 /* Path which doesn't exist */
230
231 p = strjoina(temp, "/idontexist");
e1f67bc7 232 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343
MP		 233 assert_se(r == -ENOENT);
234
e1f67bc7 235 r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
2897b343
MP		 236 assert_se(r == 0);
237 assert_se(path_equal(result, p));
238 result = mfree(result);
239
240 p = strjoina(temp, "/idontexist/meneither");
e1f67bc7 241 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343
MP		 242 assert_se(r == -ENOENT);
243
e1f67bc7 244 r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
2897b343
MP		 245 assert_se(r == 0);
246 assert_se(path_equal(result, p));
247 result = mfree(result);
248
249 /* Path which doesn't exist, but contains weird stuff */
250
251 p = strjoina(temp, "/idontexist/..");
e1f67bc7 252 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343
MP		 253 assert_se(r == -ENOENT);
254
e1f67bc7 255 r = chase_symlinks(p, NULL, CHASE_NONEXISTENT, &result, NULL);
2897b343
MP		 256 assert_se(r == -ENOENT);
257
258 p = strjoina(temp, "/target");
259 q = strjoina(temp, "/top");
260 assert_se(symlink(q, p) >= 0);
261 p = strjoina(temp, "/target/idontexist");
e1f67bc7 262 r = chase_symlinks(p, NULL, 0, &result, NULL);
2897b343
MP		 263 assert_se(r == -ENOENT);
264
1d42b86d
MB		 265 if (geteuid() == 0) {
266 p = strjoina(temp, "/priv1");
267 assert_se(mkdir(p, 0755) >= 0);
268
269 q = strjoina(p, "/priv2");
270 assert_se(mkdir(q, 0755) >= 0);
271
e1f67bc7 272 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
1d42b86d
MB		 273
274 assert_se(chown(q, UID_NOBODY, GID_NOBODY) >= 0);
e1f67bc7 275 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
1d42b86d
MB		 276
277 assert_se(chown(p, UID_NOBODY, GID_NOBODY) >= 0);
e1f67bc7 278 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
1d42b86d
MB		 279
280 assert_se(chown(q, 0, 0) >= 0);
e1f67bc7 281 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
1d42b86d
MB		 282
283 assert_se(rmdir(q) >= 0);
284 assert_se(symlink("/etc/passwd", q) >= 0);
e1f67bc7 285 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
1d42b86d
MB		 286
287 assert_se(chown(p, 0, 0) >= 0);
e1f67bc7 288 assert_se(chase_symlinks(q, NULL, CHASE_SAFE, NULL, NULL) >= 0);
1d42b86d
MB		 289 }
290
291 p = strjoina(temp, "/machine-id-test");
292 assert_se(symlink("/usr/../etc/./machine-id", p) >= 0);
293
e1f67bc7
MB		 294 r = chase_symlinks(p, NULL, 0, NULL, &pfd);
295 if (r != -ENOENT) {
1d42b86d
MB		 296 _cleanup_close_ int fd = -1;
297 sd_id128_t a, b;
298
299 assert_se(pfd >= 0);
300
b012e921 301 fd = fd_reopen(pfd, O_RDONLY|O_CLOEXEC);
1d42b86d 302 assert_se(fd >= 0);
1d42b86d
MB		 303 safe_close(pfd);
304
305 assert_se(id128_read_fd(fd, ID128_PLAIN, &a) >= 0);
306 assert_se(sd_id128_get_machine(&b) >= 0);
307 assert_se(sd_id128_equal(a, b));
308 }
309
6e866b33
MB		 310 /* Test CHASE_NOFOLLOW */
311
312 p = strjoina(temp, "/target");
313 q = strjoina(temp, "/symlink");
314 assert_se(symlink(p, q) >= 0);
e1f67bc7
MB		 315 r = chase_symlinks(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
316 assert_se(r >= 0);
317 assert_se(pfd >= 0);
6e866b33
MB		 318 assert_se(path_equal(result, q));
319 assert_se(fstat(pfd, &st) >= 0);
320 assert_se(S_ISLNK(st.st_mode));
321 result = mfree(result);
9cde670f 322 pfd = safe_close(pfd);
6e866b33
MB		 323
324 /* s1 -> s2 -> nonexistent */
325 q = strjoina(temp, "/s1");
326 assert_se(symlink("s2", q) >= 0);
327 p = strjoina(temp, "/s2");
328 assert_se(symlink("nonexistent", p) >= 0);
e1f67bc7
MB		 329 r = chase_symlinks(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
330 assert_se(r >= 0);
331 assert_se(pfd >= 0);
6e866b33
MB		 332 assert_se(path_equal(result, q));
333 assert_se(fstat(pfd, &st) >= 0);
334 assert_se(S_ISLNK(st.st_mode));
335 result = mfree(result);
9cde670f 336 pfd = safe_close(pfd);
6e866b33 337
8b3d4ff0 338 /* Test CHASE_STEP */
b012e921
MB		 339
340 p = strjoina(temp, "/start");
e1f67bc7 341 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 342 assert_se(r == 0);
343 p = strjoina(temp, "/top/dot/dotdota");
344 assert_se(streq(p, result));
345 result = mfree(result);
346
e1f67bc7 347 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921 348 assert_se(r == 0);
8b3d4ff0 349 p = strjoina(temp, "/top/dotdota");
b012e921
MB		 350 assert_se(streq(p, result));
351 result = mfree(result);
352
e1f67bc7 353 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 354 assert_se(r == 0);
355 p = strjoina(temp, "/top/../a");
356 assert_se(streq(p, result));
357 result = mfree(result);
358
e1f67bc7 359 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 360 assert_se(r == 0);
361 p = strjoina(temp, "/a");
362 assert_se(streq(p, result));
363 result = mfree(result);
364
e1f67bc7 365 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 366 assert_se(r == 0);
367 p = strjoina(temp, "/b");
368 assert_se(streq(p, result));
369 result = mfree(result);
370
e1f67bc7 371 r = chase_symlinks(p, NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 372 assert_se(r == 0);
373 assert_se(streq("/usr", result));
374 result = mfree(result);
375
e1f67bc7 376 r = chase_symlinks("/usr", NULL, CHASE_STEP, &result, NULL);
b012e921
MB		 377 assert_se(r > 0);
378 assert_se(streq("/usr", result));
379 result = mfree(result);
380
46cdbd49
BR		 381 /* Make sure that symlinks in the "root" path are not resolved, but those below are */
382 p = strjoina("/etc/..", temp, "/self");
383 assert_se(symlink(".", p) >= 0);
384 q = strjoina(p, "/top/dot/dotdota");
385 r = chase_symlinks(q, p, 0, &result, NULL);
386 assert_se(r > 0);
387 assert_se(path_equal(path_startswith(result, p), "usr"));
388 result = mfree(result);
389
6e866b33 390 cleanup:
8a584da2
MP		 391 assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
392}
393
ea0999c9 394TEST(unlink_noerrno) {
6e866b33 395 char *name;
aa27b158
MP		 396 int fd;
397
6e866b33 398 name = strjoina(arg_test_dir ?: "/tmp", "/test-close_nointr.XXXXXX");
8a584da2 399 fd = mkostemp_safe(name);
aa27b158
MP		 400 assert_se(fd >= 0);
401 assert_se(close_nointr(fd) >= 0);
402
403 {
404 PROTECT_ERRNO;
7c20daf6 405 errno = 42;
aa27b158 406 assert_se(unlink_noerrno(name) >= 0);
7c20daf6 407 assert_se(errno == 42);
aa27b158 408 assert_se(unlink_noerrno(name) < 0);
7c20daf6 409 assert_se(errno == 42);
aa27b158
MP		 410 }
411}
412
ea0999c9 413TEST(readlink_and_make_absolute) {
6e866b33
MB		 414 const char *tempdir, *name, *name2, *name_alias;
415 _cleanup_free_ char *r1 = NULL, *r2 = NULL, *pwd = NULL;
416
6e866b33
MB		 417 tempdir = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute");
418 name = strjoina(tempdir, "/original");
419 name2 = "test-readlink_and_make_absolute/original";
420 name_alias = strjoina(arg_test_dir ?: "/tmp", "/test-readlink_and_make_absolute-alias");
aa27b158 421
b012e921 422 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid(), MKDIR_WARN_MODE) >= 0);
aa27b158
MP		 423 assert_se(touch(name) >= 0);
424
6e866b33
MB		 425 if (symlink(name, name_alias) < 0) {
426 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
427 log_tests_skipped_errno(errno, "symlink() not possible");
428 } else {
429 assert_se(readlink_and_make_absolute(name_alias, &r1) >= 0);
430 assert_se(streq(r1, name));
431 assert_se(unlink(name_alias) >= 0);
aa27b158 432
6e866b33 433 assert_se(safe_getcwd(&pwd) >= 0);
52ad194e 434
6e866b33
MB		 435 assert_se(chdir(tempdir) >= 0);
436 assert_se(symlink(name2, name_alias) >= 0);
437 assert_se(readlink_and_make_absolute(name_alias, &r2) >= 0);
438 assert_se(streq(r2, name));
439 assert_se(unlink(name_alias) >= 0);
aa27b158 440
6e866b33
MB		 441 assert_se(chdir(pwd) >= 0);
442 }
52ad194e 443
aa27b158
MP		 444 assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
445}
446
ea0999c9 447TEST(get_files_in_directory) {
aa27b158
MP		 448 _cleanup_strv_free_ char **l = NULL, **t = NULL;
449
6e866b33 450 assert_se(get_files_in_directory(arg_test_dir ?: "/tmp", &l) >= 0);
aa27b158
MP		 451 assert_se(get_files_in_directory(".", &t) >= 0);
452 assert_se(get_files_in_directory(".", NULL) >= 0);
453}
454
ea0999c9 455TEST(var_tmp) {
8a584da2
MP		 456 _cleanup_free_ char *tmpdir_backup = NULL, *temp_backup = NULL, *tmp_backup = NULL;
457 const char *tmp_dir = NULL, *t;
458
459 t = getenv("TMPDIR");
460 if (t) {
461 tmpdir_backup = strdup(t);
462 assert_se(tmpdir_backup);
463 }
464
465 t = getenv("TEMP");
466 if (t) {
467 temp_backup = strdup(t);
468 assert_se(temp_backup);
5a920b42
MP		 469 }
470
8a584da2
MP		 471 t = getenv("TMP");
472 if (t) {
473 tmp_backup = strdup(t);
474 assert_se(tmp_backup);
475 }
5a920b42 476
52ad194e
MB		 477 assert_se(unsetenv("TMPDIR") >= 0);
478 assert_se(unsetenv("TEMP") >= 0);
479 assert_se(unsetenv("TMP") >= 0);
5a920b42 480
8a584da2
MP		 481 assert_se(var_tmp_dir(&tmp_dir) >= 0);
482 assert_se(streq(tmp_dir, "/var/tmp"));
5a920b42 483
8a584da2
MP		 484 assert_se(setenv("TMPDIR", "/tmp", true) >= 0);
485 assert_se(streq(getenv("TMPDIR"), "/tmp"));
5a920b42 486
8a584da2
MP		 487 assert_se(var_tmp_dir(&tmp_dir) >= 0);
488 assert_se(streq(tmp_dir, "/tmp"));
5a920b42 489
8a584da2
MP		 490 assert_se(setenv("TMPDIR", "/88_does_not_exist_88", true) >= 0);
491 assert_se(streq(getenv("TMPDIR"), "/88_does_not_exist_88"));
5a920b42 492
8a584da2
MP		 493 assert_se(var_tmp_dir(&tmp_dir) >= 0);
494 assert_se(streq(tmp_dir, "/var/tmp"));
5a920b42 495
8a584da2
MP		 496 if (tmpdir_backup) {
497 assert_se(setenv("TMPDIR", tmpdir_backup, true) >= 0);
498 assert_se(streq(getenv("TMPDIR"), tmpdir_backup));
499 }
5a920b42 500
8a584da2
MP		 501 if (temp_backup) {
502 assert_se(setenv("TEMP", temp_backup, true) >= 0);
503 assert_se(streq(getenv("TEMP"), temp_backup));
504 }
5a920b42 505
8a584da2
MP		 506 if (tmp_backup) {
507 assert_se(setenv("TMP", tmp_backup, true) >= 0);
508 assert_se(streq(getenv("TMP"), tmp_backup));
5a920b42
MP		 509 }
510}
511
ea0999c9 512TEST(dot_or_dot_dot) {
2897b343
MP		 513 assert_se(!dot_or_dot_dot(NULL));
514 assert_se(!dot_or_dot_dot(""));
515 assert_se(!dot_or_dot_dot("xxx"));
516 assert_se(dot_or_dot_dot("."));
517 assert_se(dot_or_dot_dot(".."));
518 assert_se(!dot_or_dot_dot(".foo"));
519 assert_se(!dot_or_dot_dot("..foo"));
520}
521
ea0999c9 522TEST(access_fd) {
52ad194e
MB		 523 _cleanup_(rmdir_and_freep) char *p = NULL;
524 _cleanup_close_ int fd = -1;
6e866b33
MB		 525 const char *a;
526
6e866b33
MB		 527 a = strjoina(arg_test_dir ?: "/tmp", "/access-fd.XXXXXX");
528 assert_se(mkdtemp_malloc(a, &p) >= 0);
52ad194e
MB		 529
530 fd = open(p, O_RDONLY|O_DIRECTORY|O_CLOEXEC);
531 assert_se(fd >= 0);
532
533 assert_se(access_fd(fd, R_OK) >= 0);
534 assert_se(access_fd(fd, F_OK) >= 0);
535 assert_se(access_fd(fd, W_OK) >= 0);
536
537 assert_se(fchmod(fd, 0000) >= 0);
538
539 assert_se(access_fd(fd, F_OK) >= 0);
540
541 if (geteuid() == 0) {
542 assert_se(access_fd(fd, R_OK) >= 0);
543 assert_se(access_fd(fd, W_OK) >= 0);
544 } else {
545 assert_se(access_fd(fd, R_OK) == -EACCES);
546 assert_se(access_fd(fd, W_OK) == -EACCES);
547 }
548}
549
ea0999c9 550TEST(touch_file) {
1d42b86d
MB		 551 uid_t test_uid, test_gid;
552 _cleanup_(rm_rf_physical_and_freep) char *p = NULL;
553 struct stat st;
554 const char *a;
555 usec_t test_mtime;
6e866b33
MB		 556 int r;
557
1d42b86d
MB		 558 test_uid = geteuid() == 0 ? 65534 : getuid();
559 test_gid = geteuid() == 0 ? 65534 : getgid();
560
561 test_mtime = usec_sub_unsigned(now(CLOCK_REALTIME), USEC_PER_WEEK);
562
6e866b33
MB		 563 a = strjoina(arg_test_dir ?: "/dev/shm", "/touch-file-XXXXXX");
564 assert_se(mkdtemp_malloc(a, &p) >= 0);
1d42b86d
MB		 565
566 a = strjoina(p, "/regular");
6e866b33
MB		 567 r = touch_file(a, false, test_mtime, test_uid, test_gid, 0640);
568 if (r < 0) {
569 assert_se(IN_SET(r, -EINVAL, -ENOSYS, -ENOTTY, -EPERM));
570 log_tests_skipped_errno(errno, "touch_file() not possible");
571 return;
572 }
573
1d42b86d
MB		 574 assert_se(lstat(a, &st) >= 0);
575 assert_se(st.st_uid == test_uid);
576 assert_se(st.st_gid == test_gid);
577 assert_se(S_ISREG(st.st_mode));
578 assert_se((st.st_mode & 0777) == 0640);
579 assert_se(timespec_load(&st.st_mtim) == test_mtime);
580
581 a = strjoina(p, "/dir");
582 assert_se(mkdir(a, 0775) >= 0);
583 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
584 assert_se(lstat(a, &st) >= 0);
585 assert_se(st.st_uid == test_uid);
586 assert_se(st.st_gid == test_gid);
587 assert_se(S_ISDIR(st.st_mode));
588 assert_se((st.st_mode & 0777) == 0640);
589 assert_se(timespec_load(&st.st_mtim) == test_mtime);
590
591 a = strjoina(p, "/fifo");
592 assert_se(mkfifo(a, 0775) >= 0);
593 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
594 assert_se(lstat(a, &st) >= 0);
595 assert_se(st.st_uid == test_uid);
596 assert_se(st.st_gid == test_gid);
597 assert_se(S_ISFIFO(st.st_mode));
598 assert_se((st.st_mode & 0777) == 0640);
599 assert_se(timespec_load(&st.st_mtim) == test_mtime);
600
601 a = strjoina(p, "/sock");
602 assert_se(mknod(a, 0775 | S_IFSOCK, 0) >= 0);
603 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
604 assert_se(lstat(a, &st) >= 0);
605 assert_se(st.st_uid == test_uid);
606 assert_se(st.st_gid == test_gid);
607 assert_se(S_ISSOCK(st.st_mode));
608 assert_se((st.st_mode & 0777) == 0640);
609 assert_se(timespec_load(&st.st_mtim) == test_mtime);
610
611 if (geteuid() == 0) {
5e42acaf
MB		 612 a = strjoina(p, "/bdev");
613 r = mknod(a, 0775 | S_IFBLK, makedev(0, 0));
6e866b33
MB		 614 if (r < 0 && errno == EPERM && detect_container() > 0) {
615 log_notice("Running in unprivileged container? Skipping remaining tests in %s", __func__);
616 return;
617 }
618 assert_se(r >= 0);
1d42b86d
MB		 619 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
620 assert_se(lstat(a, &st) >= 0);
621 assert_se(st.st_uid == test_uid);
622 assert_se(st.st_gid == test_gid);
5e42acaf 623 assert_se(S_ISBLK(st.st_mode));
1d42b86d
MB		 624 assert_se((st.st_mode & 0777) == 0640);
625 assert_se(timespec_load(&st.st_mtim) == test_mtime);
626
5e42acaf
MB		 627 a = strjoina(p, "/cdev");
628 assert_se(mknod(a, 0775 | S_IFCHR, makedev(0, 0)) >= 0);
1d42b86d
MB		 629 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
630 assert_se(lstat(a, &st) >= 0);
631 assert_se(st.st_uid == test_uid);
632 assert_se(st.st_gid == test_gid);
5e42acaf 633 assert_se(S_ISCHR(st.st_mode));
1d42b86d
MB		 634 assert_se((st.st_mode & 0777) == 0640);
635 assert_se(timespec_load(&st.st_mtim) == test_mtime);
636 }
637
638 a = strjoina(p, "/lnk");
639 assert_se(symlink("target", a) >= 0);
640 assert_se(touch_file(a, false, test_mtime, test_uid, test_gid, 0640) >= 0);
641 assert_se(lstat(a, &st) >= 0);
642 assert_se(st.st_uid == test_uid);
643 assert_se(st.st_gid == test_gid);
644 assert_se(S_ISLNK(st.st_mode));
1d42b86d
MB		 645 assert_se(timespec_load(&st.st_mtim) == test_mtime);
646}
647
ea0999c9 648TEST(unlinkat_deallocate) {
98393f85
MB		 649 _cleanup_free_ char *p = NULL;
650 _cleanup_close_ int fd = -1;
651 struct stat st;
652
6e866b33 653 assert_se(tempfn_random_child(arg_test_dir, "unlink-deallocation", &p) >= 0);
98393f85
MB		 654
655 fd = open(p, O_WRONLY|O_CLOEXEC|O_CREAT|O_EXCL, 0600);
656 assert_se(fd >= 0);
657
658 assert_se(write(fd, "hallo\n", 6) == 6);
659
660 assert_se(fstat(fd, &st) >= 0);
661 assert_se(st.st_size == 6);
662 assert_se(st.st_blocks > 0);
663 assert_se(st.st_nlink == 1);
664
a10f5d05 665 assert_se(unlinkat_deallocate(AT_FDCWD, p, UNLINK_ERASE) >= 0);
98393f85
MB		 666
667 assert_se(fstat(fd, &st) >= 0);
6e866b33
MB		 668 assert_se(IN_SET(st.st_size, 0, 6)); /* depending on whether hole punching worked the size will be 6
669 (it worked) or 0 (we had to resort to truncation) */
98393f85
MB		 670 assert_se(st.st_blocks == 0);
671 assert_se(st.st_nlink == 0);
672}
673
ea0999c9 674TEST(fsync_directory_of_file) {
98393f85
MB		 675 _cleanup_close_ int fd = -1;
676
6e866b33 677 fd = open_tmpfile_unlinkable(arg_test_dir, O_RDWR);
98393f85
MB		 678 assert_se(fd >= 0);
679
680 assert_se(fsync_directory_of_file(fd) >= 0);
681}
682
ea0999c9 683TEST(rename_noreplace) {
6e866b33
MB		 684 static const char* const table[] = {
685 "/reg",
686 "/dir",
687 "/fifo",
688 "/socket",
689 "/symlink",
690 NULL
691 };
692
693 _cleanup_(rm_rf_physical_and_freep) char *z = NULL;
694 const char *j = NULL;
695 char **a, **b;
696
6e866b33
MB		 697 if (arg_test_dir)
698 j = strjoina(arg_test_dir, "/testXXXXXX");
699 assert_se(mkdtemp_malloc(j, &z) >= 0);
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) {
728 _cleanup_free_ char *w = NULL;
729
46cdbd49 730 w = strjoin(z, *b);
6e866b33
MB		 731 assert_se(w);
732
733 if (access(w, F_OK) < 0) {
734 assert_se(errno == ENOENT);
735 continue;
736 }
737
46cdbd49 738 assert_se(rename_noreplace(AT_FDCWD, x, AT_FDCWD, w) == -EEXIST);
6e866b33
MB		 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
ea0999c9 749TEST(chmod_and_chown) {
f2dec872 750 _cleanup_(rm_rf_physical_and_freep) char *d = NULL;
f2dec872
BR		 751 struct stat st;
752 const char *p;
753
754 if (geteuid() != 0)
755 return;
756
ea0999c9 757 BLOCK_WITH_UMASK(0000);
f2dec872
BR		 758
759 assert_se(mkdtemp_malloc(NULL, &d) >= 0);
760
761 p = strjoina(d, "/reg");
762 assert_se(mknod(p, S_IFREG | 0123, 0) >= 0);
763
764 assert_se(chmod_and_chown(p, S_IFREG | 0321, 1, 2) >= 0);
765 assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL);
766
767 assert_se(lstat(p, &st) >= 0);
768 assert_se(S_ISREG(st.st_mode));
769 assert_se((st.st_mode & 07777) == 0321);
770
771 p = strjoina(d, "/dir");
772 assert_se(mkdir(p, 0123) >= 0);
773
774 assert_se(chmod_and_chown(p, S_IFDIR | 0321, 1, 2) >= 0);
775 assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL);
776
777 assert_se(lstat(p, &st) >= 0);
778 assert_se(S_ISDIR(st.st_mode));
779 assert_se((st.st_mode & 07777) == 0321);
780
781 p = strjoina(d, "/lnk");
782 assert_se(symlink("idontexist", p) >= 0);
783
784 assert_se(chmod_and_chown(p, S_IFLNK | 0321, 1, 2) >= 0);
785 assert_se(chmod_and_chown(p, S_IFREG | 0555, 3, 4) == -EINVAL);
786 assert_se(chmod_and_chown(p, S_IFDIR | 0555, 3, 4) == -EINVAL);
787
788 assert_se(lstat(p, &st) >= 0);
789 assert_se(S_ISLNK(st.st_mode));
790}
791
3a6ce677
BR		 792static void create_binary_file(const char *p, const void *data, size_t l) {
793 _cleanup_close_ int fd = -1;
794
795 fd = open(p, O_CREAT|O_WRONLY|O_EXCL|O_CLOEXEC, 0600);
796 assert_se(fd >= 0);
797 assert_se(write(fd, data, l) == (ssize_t) l);
798}
799
ea0999c9 800TEST(conservative_rename) {
3a6ce677
BR		 801 _cleanup_(unlink_and_freep) char *p = NULL;
802 _cleanup_free_ char *q = NULL;
803 size_t l = 16*1024 + random_u64() % (32 * 1024); /* some randomly sized buffer 16k…48k */
804 uint8_t buffer[l+1];
805
806 random_bytes(buffer, l);
807
808 assert_se(tempfn_random_child(NULL, NULL, &p) >= 0);
809 create_binary_file(p, buffer, l);
810
811 assert_se(tempfn_random_child(NULL, NULL, &q) >= 0);
812
813 /* Check that the hardlinked "copy" is detected */
814 assert_se(link(p, q) >= 0);
815 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
816 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
817
818 /* Check that a manual copy is detected */
819 assert_se(copy_file(p, q, 0, MODE_INVALID, 0, 0, COPY_REFLINK) >= 0);
820 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
821 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
822
823 /* Check that a manual new writeout is also detected */
824 create_binary_file(q, buffer, l);
825 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
826 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
827
828 /* Check that a minimally changed version is detected */
829 buffer[47] = ~buffer[47];
830 create_binary_file(q, buffer, l);
831 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
832 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
833
834 /* Check that this really is new updated version */
835 create_binary_file(q, buffer, l);
836 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) == 0);
837 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
838
839 /* Make sure we detect extended files */
840 buffer[l++] = 47;
841 create_binary_file(q, buffer, l);
842 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
843 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
844
845 /* Make sure we detect truncated files */
846 l--;
847 create_binary_file(q, buffer, l);
848 assert_se(conservative_renameat(AT_FDCWD, q, AT_FDCWD, p) > 0);
849 assert_se(access(q, F_OK) < 0 && errno == ENOENT);
850}
851
ea0999c9
MB		 852static void test_rmdir_parents_one(
853 const char *prefix,
854 const char *path,
855 const char *stop,
856 int expected,
857 const char *test_exist,
858 const char *test_nonexist_subdir) {
859
860 const char *p, *s;
861
862 log_debug("/* %s(%s, %s) */", __func__, path, stop);
863
864 p = strjoina(prefix, path);
865 s = strjoina(prefix, stop);
866
867 if (expected >= 0)
868 assert_se(mkdir_parents(p, 0700) >= 0);
869
870 assert_se(rmdir_parents(p, s) == expected);
871
872 if (expected >= 0) {
873 const char *e, *f;
874
875 e = strjoina(prefix, test_exist);
876 f = strjoina(e, test_nonexist_subdir);
877
878 assert_se(access(e, F_OK) >= 0);
879 assert_se(access(f, F_OK) < 0);
880 }
aa27b158 881}
ea0999c9
MB		 882
883TEST(rmdir_parents) {
884 char *temp;
885
886 temp = strjoina(arg_test_dir ?: "/tmp", "/test-rmdir.XXXXXX");
887 assert_se(mkdtemp(temp));
888
889 test_rmdir_parents_one(temp, "/aaa/../hoge/foo", "/hoge/foo", -EINVAL, NULL, NULL);
890 test_rmdir_parents_one(temp, "/aaa/bbb/ccc", "/hoge/../aaa", -EINVAL, NULL, NULL);
891
892 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb/ccc/ddd", 0, "/aaa/bbb/ccc/ddd", "/eee");
893 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb/ccc", 0, "/aaa/bbb/ccc", "/ddd");
894 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/bbb", 0, "/aaa/bbb", "/ccc");
895 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa", 0, "/aaa", "/bbb");
896 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/", 0, "/", "/aaa");
897
898 test_rmdir_parents_one(temp, "/aaa/bbb/ccc/ddd/eee", "/aaa/hoge/foo", 0, "/aaa", "/bbb");
899 test_rmdir_parents_one(temp, "/aaa////bbb/.//ccc//ddd/eee///./.", "///././aaa/.", 0, "/aaa", "/bbb");
900
901 assert_se(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
902}
903
904static void test_parse_cifs_service_one(const char *f, const char *h, const char *s, const char *d, int ret) {
905 _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL;
906
907 assert_se(parse_cifs_service(f, &a, &b, &c) == ret);
908 assert_se(streq_ptr(a, h));
909 assert_se(streq_ptr(b, s));
910 assert_se(streq_ptr(c, d));
911}
912
913TEST(parse_cifs_service) {
914 test_parse_cifs_service_one("//foo/bar/baz", "foo", "bar", "baz", 0);
915 test_parse_cifs_service_one("\\\\foo\\bar\\baz", "foo", "bar", "baz", 0);
916 test_parse_cifs_service_one("//foo/bar", "foo", "bar", NULL, 0);
917 test_parse_cifs_service_one("\\\\foo\\bar", "foo", "bar", NULL, 0);
918 test_parse_cifs_service_one("//foo/bar/baz/uuu", "foo", "bar", "baz/uuu", 0);
919 test_parse_cifs_service_one("\\\\foo\\bar\\baz\\uuu", "foo", "bar", "baz/uuu", 0);
920
921 test_parse_cifs_service_one(NULL, NULL, NULL, NULL, -EINVAL);
922 test_parse_cifs_service_one("", NULL, NULL, NULL, -EINVAL);
923 test_parse_cifs_service_one("abc", NULL, NULL, NULL, -EINVAL);
924 test_parse_cifs_service_one("abc/cde/efg", NULL, NULL, NULL, -EINVAL);
925 test_parse_cifs_service_one("//foo/bar/baz/..", NULL, NULL, NULL, -EINVAL);
926 test_parse_cifs_service_one("//foo///", NULL, NULL, NULL, -EINVAL);
927 test_parse_cifs_service_one("//foo/.", NULL, NULL, NULL, -EINVAL);
928 test_parse_cifs_service_one("//foo/a/.", NULL, NULL, NULL, -EINVAL);
929 test_parse_cifs_service_one("//./a", NULL, NULL, NULL, -EINVAL);
930}
931
932TEST(open_mkdir_at) {
933 _cleanup_close_ int fd = -1, subdir_fd = -1, subsubdir_fd = -1;
934 _cleanup_(rm_rf_physical_and_freep) char *t = NULL;
935
936 assert_se(open_mkdir_at(AT_FDCWD, "/proc", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
937
938 fd = open_mkdir_at(AT_FDCWD, "/proc", O_CLOEXEC, 0);
939 assert_se(fd >= 0);
940 fd = safe_close(fd);
941
942 assert_se(open_mkdir_at(AT_FDCWD, "/bin/sh", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
943 assert_se(open_mkdir_at(AT_FDCWD, "/bin/sh", O_CLOEXEC, 0) == -EEXIST);
944
945 assert_se(mkdtemp_malloc(NULL, &t) >= 0);
946
947 assert_se(open_mkdir_at(AT_FDCWD, t, O_EXCL|O_CLOEXEC, 0) == -EEXIST);
948 assert_se(open_mkdir_at(AT_FDCWD, t, O_PATH|O_EXCL|O_CLOEXEC, 0) == -EEXIST);
949
950 fd = open_mkdir_at(AT_FDCWD, t, O_CLOEXEC, 0000);
951 assert_se(fd >= 0);
952 fd = safe_close(fd);
953
954 fd = open_mkdir_at(AT_FDCWD, t, O_PATH|O_CLOEXEC, 0000);
955 assert_se(fd >= 0);
956
957 subdir_fd = open_mkdir_at(fd, "xxx", O_PATH|O_EXCL|O_CLOEXEC, 0700);
958 assert_se(subdir_fd >= 0);
959
960 assert_se(open_mkdir_at(fd, "xxx", O_PATH|O_EXCL|O_CLOEXEC, 0) == -EEXIST);
961
962 subsubdir_fd = open_mkdir_at(subdir_fd, "yyy", O_EXCL|O_CLOEXEC, 0700);
963 assert_se(subsubdir_fd >= 0);
964 subsubdir_fd = safe_close(subsubdir_fd);
965
966 assert_se(open_mkdir_at(subdir_fd, "yyy", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
967
968 assert_se(open_mkdir_at(fd, "xxx/yyy", O_EXCL|O_CLOEXEC, 0) == -EEXIST);
969
970 subsubdir_fd = open_mkdir_at(fd, "xxx/yyy", O_CLOEXEC, 0700);
971 assert_se(subsubdir_fd >= 0);
972}
973
974DEFINE_CUSTOM_TEST_MAIN(LOG_INFO, arg_test_dir = argv[1], /* no outro */);
systemd for Proxmox projects