]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/test/test-chase.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
io.systemd.Unit.List fix context/runtime split (#38172)
[thirdparty/systemd.git] / src / test / test-chase.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include <stdlib.h>
4#include <unistd.h>
5
6#include "alloc-util.h"
7#include "argv-util.h"
8#include "chase.h"
9#include "dirent-util.h"
10#include "fd-util.h"
11#include "fs-util.h"
12#include "id128-util.h"
13#include "mkdir.h"
14#include "path-util.h"
15#include "random-util.h"
16#include "rm-rf.h"
17#include "stat-util.h"
18#include "string-util.h"
19#include "tests.h"
20#include "tmpfile-util.h"
21#include "user-util.h"
22
23static const char *arg_test_dir = NULL;
24
25static void test_chase_extract_filename_one(const char *path, const char *root, const char *expected) {
26 _cleanup_free_ char *ret1 = NULL, *ret2 = NULL, *fname = NULL;
27
28 log_debug("/* %s(path=%s, root=%s) */", __func__, path, strnull(root));
29
30 assert_se(chase(path, root, CHASE_EXTRACT_FILENAME, &ret1, NULL) > 0);
31 ASSERT_STREQ(ret1, expected);
32
33 assert_se(chase(path, root, 0, &ret2, NULL) > 0);
34 ASSERT_OK(chase_extract_filename(ret2, root, &fname));
35 ASSERT_STREQ(fname, expected);
36}
37
38TEST(chase) {
39 _cleanup_free_ char *result = NULL, *pwd = NULL;
40 _cleanup_close_ int pfd = -EBADF;
41 char *temp;
42 const char *top, *p, *pslash, *q, *qslash;
43 struct stat st;
44 int r;
45
46 temp = strjoina(arg_test_dir ?: "/tmp", "/test-chase.XXXXXX");
47 assert_se(mkdtemp(temp));
48
49 top = strjoina(temp, "/top");
50 ASSERT_OK(mkdir(top, 0700));
51
52 p = strjoina(top, "/dot");
53 if (symlink(".", p) < 0) {
54 assert_se(IN_SET(errno, EINVAL, ENOSYS, ENOTTY, EPERM));
55 log_tests_skipped_errno(errno, "symlink() not possible");
56 goto cleanup;
57 };
58
59 p = strjoina(top, "/dotdot");
60 ASSERT_OK(symlink("..", p));
61
62 p = strjoina(top, "/dotdota");
63 ASSERT_OK(symlink("../a", p));
64
65 p = strjoina(temp, "/a");
66 ASSERT_OK(symlink("b", p));
67
68 p = strjoina(temp, "/b");
69 ASSERT_OK(symlink("/usr", p));
70
71 p = strjoina(temp, "/start");
72 ASSERT_OK(symlink("top/dot/dotdota", p));
73
74 /* Paths that use symlinks underneath the "root" */
75
76 r = chase(p, NULL, 0, &result, NULL);
77 assert_se(r > 0);
78 assert_se(path_equal(result, "/usr"));
79 result = mfree(result);
80
81 r = chase(p, "/.//../../../", 0, &result, NULL);
82 assert_se(r > 0);
83 assert_se(path_equal(result, "/usr"));
84 result = mfree(result);
85
86 pslash = strjoina(p, "/");
87 r = chase(pslash, NULL, 0, &result, NULL);
88 assert_se(r > 0);
89 assert_se(path_equal(result, "/usr/"));
90 result = mfree(result);
91
92 r = chase(p, temp, 0, &result, NULL);
93 assert_se(r == -ENOENT);
94
95 r = chase(pslash, temp, 0, &result, NULL);
96 assert_se(r == -ENOENT);
97
98 q = strjoina(temp, "/usr");
99
100 r = chase(p, temp, CHASE_NONEXISTENT, &result, NULL);
101 assert_se(r == 0);
102 assert_se(path_equal(result, q));
103 result = mfree(result);
104
105 qslash = strjoina(q, "/");
106
107 r = chase(pslash, temp, CHASE_NONEXISTENT, &result, NULL);
108 assert_se(r == 0);
109 assert_se(path_equal(result, qslash));
110 result = mfree(result);
111
112 ASSERT_OK(mkdir(q, 0700));
113
114 r = chase(p, temp, 0, &result, NULL);
115 assert_se(r > 0);
116 assert_se(path_equal(result, q));
117 result = mfree(result);
118
119 r = chase(pslash, temp, 0, &result, NULL);
120 assert_se(r > 0);
121 assert_se(path_equal(result, qslash));
122 result = mfree(result);
123
124 p = strjoina(temp, "/slash");
125 assert_se(symlink("/", p) >= 0);
126
127 r = chase(p, NULL, 0, &result, NULL);
128 assert_se(r > 0);
129 assert_se(path_equal(result, "/"));
130 result = mfree(result);
131
132 r = chase(p, temp, 0, &result, NULL);
133 assert_se(r > 0);
134 assert_se(path_equal(result, temp));
135 result = mfree(result);
136
137 /* Tests for CHASE_EXTRACT_FILENAME and chase_extract_filename() */
138
139 p = strjoina(temp, "/start");
140 pslash = strjoina(p, "/");
141 test_chase_extract_filename_one(p, NULL, "usr");
142 test_chase_extract_filename_one(pslash, NULL, "usr");
143 test_chase_extract_filename_one(p, temp, "usr");
144 test_chase_extract_filename_one(pslash, temp, "usr");
145
146 p = strjoina(temp, "/slash");
147 test_chase_extract_filename_one(p, NULL, ".");
148 test_chase_extract_filename_one(p, temp, ".");
149
150 /* Paths that would "escape" outside of the "root" */
151
152 p = strjoina(temp, "/6dots");
153 ASSERT_OK(symlink("../../..", p));
154
155 r = chase(p, temp, 0, &result, NULL);
156 assert_se(r > 0 && path_equal(result, temp));
157 result = mfree(result);
158
159 p = strjoina(temp, "/6dotsusr");
160 ASSERT_OK(symlink("../../../usr", p));
161
162 r = chase(p, temp, 0, &result, NULL);
163 assert_se(r > 0 && path_equal(result, q));
164 result = mfree(result);
165
166 p = strjoina(temp, "/top/8dotsusr");
167 ASSERT_OK(symlink("../../../../usr", p));
168
169 r = chase(p, temp, 0, &result, NULL);
170 assert_se(r > 0 && path_equal(result, q));
171 result = mfree(result);
172
173 /* Paths that contain repeated slashes */
174
175 p = strjoina(temp, "/slashslash");
176 ASSERT_OK(symlink("///usr///", p));
177
178 r = chase(p, NULL, 0, &result, NULL);
179 assert_se(r > 0);
180 assert_se(path_equal(result, "/usr"));
181 ASSERT_STREQ(result, "/usr"); /* we guarantee that we drop redundant slashes */
182 result = mfree(result);
183
184 r = chase(p, temp, 0, &result, NULL);
185 assert_se(r > 0);
186 assert_se(path_equal(result, q));
187 result = mfree(result);
188
189 /* Paths underneath the "root" with different UIDs while using CHASE_SAFE */
190
191 if (geteuid() == 0 && !userns_has_single_user()) {
192 p = strjoina(temp, "/user");
193 ASSERT_OK(mkdir(p, 0755));
194 ASSERT_OK(chown(p, UID_NOBODY, GID_NOBODY));
195
196 q = strjoina(temp, "/user/root");
197 ASSERT_OK(mkdir(q, 0755));
198
199 p = strjoina(q, "/link");
200 ASSERT_OK(symlink("/", p));
201
202 /* Fail when user-owned directories contain root-owned subdirectories. */
203 r = chase(p, temp, CHASE_SAFE, &result, NULL);
204 assert_se(r == -ENOLINK);
205 result = mfree(result);
206
207 /* Allow this when the user-owned directories are all in the "root". */
208 r = chase(p, q, CHASE_SAFE, &result, NULL);
209 assert_se(r > 0);
210 result = mfree(result);
211 }
212
213 /* Paths using . */
214
215 r = chase("/etc/./.././", NULL, 0, &result, NULL);
216 assert_se(r > 0);
217 assert_se(path_equal(result, "/"));
218 result = mfree(result);
219
220 r = chase("/etc/./.././", "/etc", 0, &result, NULL);
221 assert_se(r > 0 && path_equal(result, "/etc"));
222 result = mfree(result);
223
224 r = chase("/../.././//../../etc", NULL, 0, &result, NULL);
225 assert_se(r > 0);
226 ASSERT_STREQ(result, "/etc");
227 result = mfree(result);
228
229 r = chase("/../.././//../../test-chase.fsldajfl", NULL, CHASE_NONEXISTENT, &result, NULL);
230 assert_se(r == 0);
231 ASSERT_STREQ(result, "/test-chase.fsldajfl");
232 result = mfree(result);
233
234 r = chase("/../.././//../../etc", "/", CHASE_PREFIX_ROOT, &result, NULL);
235 assert_se(r > 0);
236 ASSERT_STREQ(result, "/etc");
237 result = mfree(result);
238
239 r = chase("/../.././//../../test-chase.fsldajfl", "/", CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result, NULL);
240 assert_se(r == 0);
241 ASSERT_STREQ(result, "/test-chase.fsldajfl");
242 result = mfree(result);
243
244 r = chase("/.path/with/dot", temp, CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &result, NULL);
245 ASSERT_OK(r);
246 q = strjoina(temp, "/.path/with/dot");
247 ASSERT_STREQ(result, q);
248 result = mfree(result);
249
250 r = chase("/etc/machine-id/foo", NULL, 0, &result, NULL);
251 assert_se(IN_SET(r, -ENOTDIR, -ENOENT));
252 result = mfree(result);
253
254 /* Path that loops back to self */
255
256 p = strjoina(temp, "/recursive-symlink");
257 ASSERT_OK(symlink("recursive-symlink", p));
258 r = chase(p, NULL, 0, &result, NULL);
259 assert_se(r == -ELOOP);
260
261 /* Path which doesn't exist */
262
263 p = strjoina(temp, "/idontexist");
264 r = chase(p, NULL, 0, &result, NULL);
265 assert_se(r == -ENOENT);
266
267 r = chase(p, NULL, CHASE_NONEXISTENT, &result, NULL);
268 assert_se(r == 0);
269 assert_se(path_equal(result, p));
270 result = mfree(result);
271
272 p = strjoina(temp, "/idontexist/meneither");
273 r = chase(p, NULL, 0, &result, NULL);
274 assert_se(r == -ENOENT);
275
276 r = chase(p, NULL, CHASE_NONEXISTENT, &result, NULL);
277 assert_se(r == 0);
278 assert_se(path_equal(result, p));
279 result = mfree(result);
280
281 /* Relative paths */
282
283 ASSERT_OK(safe_getcwd(&pwd));
284
285 ASSERT_OK(chdir(temp));
286
287 p = "this/is/a/relative/path";
288 r = chase(p, NULL, CHASE_NONEXISTENT, &result, NULL);
289 assert_se(r == 0);
290
291 p = strjoina(temp, "/", p);
292 assert_se(path_equal(result, p));
293 result = mfree(result);
294
295 p = "this/is/a/relative/path";
296 r = chase(p, temp, CHASE_NONEXISTENT, &result, NULL);
297 assert_se(r == 0);
298
299 p = strjoina(temp, "/", p);
300 assert_se(path_equal(result, p));
301 result = mfree(result);
302
303 assert_se(chdir(pwd) >= 0);
304
305 /* Path which doesn't exist, but contains weird stuff */
306
307 p = strjoina(temp, "/idontexist/..");
308 r = chase(p, NULL, 0, &result, NULL);
309 assert_se(r == -ENOENT);
310
311 r = chase(p, NULL, CHASE_NONEXISTENT, &result, NULL);
312 assert_se(r == -ENOENT);
313
314 p = strjoina(temp, "/target");
315 q = strjoina(temp, "/top");
316 assert_se(symlink(q, p) >= 0);
317 p = strjoina(temp, "/target/idontexist");
318 r = chase(p, NULL, 0, &result, NULL);
319 assert_se(r == -ENOENT);
320
321 if (geteuid() == 0 && !userns_has_single_user()) {
322 p = strjoina(temp, "/priv1");
323 ASSERT_OK(mkdir(p, 0755));
324
325 q = strjoina(p, "/priv2");
326 ASSERT_OK(mkdir(q, 0755));
327
328 ASSERT_OK(chase(q, NULL, CHASE_SAFE, NULL, NULL));
329
330 ASSERT_OK(chown(q, UID_NOBODY, GID_NOBODY));
331 ASSERT_OK(chase(q, NULL, CHASE_SAFE, NULL, NULL));
332
333 ASSERT_OK(chown(p, UID_NOBODY, GID_NOBODY));
334 ASSERT_OK(chase(q, NULL, CHASE_SAFE, NULL, NULL));
335
336 assert_se(chown(q, 0, 0) >= 0);
337 assert_se(chase(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
338
339 ASSERT_OK(rmdir(q));
340 ASSERT_OK(symlink("/etc/passwd", q));
341 assert_se(chase(q, NULL, CHASE_SAFE, NULL, NULL) == -ENOLINK);
342
343 assert_se(chown(p, 0, 0) >= 0);
344 ASSERT_OK(chase(q, NULL, CHASE_SAFE, NULL, NULL));
345 }
346
347 p = strjoina(temp, "/machine-id-test");
348 ASSERT_OK(symlink("/usr/../etc/./machine-id", p));
349
350 r = chase(p, NULL, 0, NULL, &pfd);
351 if (r != -ENOENT && sd_id128_get_machine(NULL) >= 0) {
352 _cleanup_close_ int fd = -EBADF;
353 sd_id128_t a, b;
354
355 ASSERT_OK(pfd);
356
357 fd = fd_reopen(pfd, O_RDONLY|O_CLOEXEC);
358 ASSERT_OK(fd);
359 safe_close(pfd);
360
361 ASSERT_OK(id128_read_fd(fd, ID128_FORMAT_PLAIN, &a));
362 ASSERT_OK(sd_id128_get_machine(&b));
363 assert_se(sd_id128_equal(a, b));
364 }
365
366 assert_se(lstat(p, &st) >= 0);
367 r = chase_and_unlink(p, NULL, 0, 0, &result);
368 assert_se(r == 0);
369 assert_se(path_equal(result, p));
370 result = mfree(result);
371 assert_se(lstat(p, &st) == -1 && errno == ENOENT);
372
373 /* Test CHASE_NOFOLLOW */
374
375 p = strjoina(temp, "/target");
376 q = strjoina(temp, "/symlink");
377 assert_se(symlink(p, q) >= 0);
378 r = chase(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
379 ASSERT_OK(r);
380 ASSERT_OK(pfd);
381 assert_se(path_equal(result, q));
382 ASSERT_OK(fstat(pfd, &st));
383 assert_se(S_ISLNK(st.st_mode));
384 result = mfree(result);
385 pfd = safe_close(pfd);
386
387 /* s1 -> s2 -> nonexistent */
388 q = strjoina(temp, "/s1");
389 ASSERT_OK(symlink("s2", q));
390 p = strjoina(temp, "/s2");
391 ASSERT_OK(symlink("nonexistent", p));
392 r = chase(q, NULL, CHASE_NOFOLLOW, &result, &pfd);
393 ASSERT_OK(r);
394 ASSERT_OK(pfd);
395 assert_se(path_equal(result, q));
396 ASSERT_OK(fstat(pfd, &st));
397 assert_se(S_ISLNK(st.st_mode));
398 result = mfree(result);
399 pfd = safe_close(pfd);
400
401 /* Test CHASE_STEP */
402
403 p = strjoina(temp, "/start");
404 r = chase(p, NULL, CHASE_STEP, &result, NULL);
405 assert_se(r == 0);
406 p = strjoina(temp, "/top/dot/dotdota");
407 ASSERT_STREQ(p, result);
408 result = mfree(result);
409
410 r = chase(p, NULL, CHASE_STEP, &result, NULL);
411 assert_se(r == 0);
412 p = strjoina(temp, "/top/dotdota");
413 ASSERT_STREQ(p, result);
414 result = mfree(result);
415
416 r = chase(p, NULL, CHASE_STEP, &result, NULL);
417 assert_se(r == 0);
418 p = strjoina(temp, "/top/../a");
419 ASSERT_STREQ(p, result);
420 result = mfree(result);
421
422 r = chase(p, NULL, CHASE_STEP, &result, NULL);
423 assert_se(r == 0);
424 p = strjoina(temp, "/a");
425 ASSERT_STREQ(p, result);
426 result = mfree(result);
427
428 r = chase(p, NULL, CHASE_STEP, &result, NULL);
429 assert_se(r == 0);
430 p = strjoina(temp, "/b");
431 ASSERT_STREQ(p, result);
432 result = mfree(result);
433
434 r = chase(p, NULL, CHASE_STEP, &result, NULL);
435 assert_se(r == 0);
436 ASSERT_STREQ("/usr", result);
437 result = mfree(result);
438
439 r = chase("/usr", NULL, CHASE_STEP, &result, NULL);
440 assert_se(r > 0);
441 ASSERT_STREQ("/usr", result);
442 result = mfree(result);
443
444 /* Make sure that symlinks in the "root" path are not resolved, but those below are */
445 p = strjoina("/etc/..", temp, "/self");
446 assert_se(symlink(".", p) >= 0);
447 q = strjoina(p, "/top/dot/dotdota");
448 r = chase(q, p, 0, &result, NULL);
449 assert_se(r > 0);
450 assert_se(path_equal(path_startswith(result, p), "usr"));
451 result = mfree(result);
452
453 /* Test CHASE_PROHIBIT_SYMLINKS */
454
455 assert_se(chase("top/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
456 assert_se(chase("top/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
457 assert_se(chase("top/dotdot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
458 assert_se(chase("top/dotdot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
459 assert_se(chase("top/dot/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS, NULL, NULL) == -EREMCHG);
460 assert_se(chase("top/dot/dot", temp, CHASE_PREFIX_ROOT|CHASE_PROHIBIT_SYMLINKS|CHASE_WARN, NULL, NULL) == -EREMCHG);
461
462 cleanup:
463 ASSERT_OK(rm_rf(temp, REMOVE_ROOT|REMOVE_PHYSICAL));
464}
465
466TEST(chaseat) {
467 _cleanup_(rm_rf_physical_and_freep) char *t = NULL;
468 _cleanup_close_ int tfd = -EBADF, fd = -EBADF;
469 _cleanup_free_ char *result = NULL;
470 _cleanup_closedir_ DIR *dir = NULL;
471 _cleanup_fclose_ FILE *f = NULL;
472 struct stat st;
473 const char *p;
474
475 ASSERT_OK(tfd = mkdtemp_open(NULL, 0, &t));
476
477 /* Test that AT_FDCWD with CHASE_AT_RESOLVE_IN_ROOT resolves against / and not the current working
478 * directory. */
479
480 ASSERT_OK(symlinkat("/usr", tfd, "abc"));
481
482 p = strjoina(t, "/abc");
483 ASSERT_OK(chaseat(AT_FDCWD, p, CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
484 ASSERT_STREQ(result, "/usr");
485 result = mfree(result);
486
487 /* If the file descriptor points to the root directory, the result will be absolute. */
488
489 fd = open("/", O_CLOEXEC | O_DIRECTORY | O_PATH);
490 ASSERT_OK(fd);
491
492 ASSERT_OK(chaseat(fd, p, 0, &result, NULL));
493 ASSERT_STREQ(result, "/usr");
494 result = mfree(result);
495
496 ASSERT_OK(chaseat(fd, p, CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
497 ASSERT_STREQ(result, "/usr");
498 result = mfree(result);
499
500 fd = safe_close(fd);
501
502 /* If the file descriptor does not point to the root directory, the result will be relative
503 * unless the result is outside of the specified file descriptor. */
504
505 ASSERT_OK(chaseat(tfd, "abc", 0, &result, NULL));
506 ASSERT_STREQ(result, "/usr");
507 result = mfree(result);
508
509 ASSERT_OK(chaseat(tfd, "/abc", 0, &result, NULL));
510 ASSERT_STREQ(result, "/usr");
511 result = mfree(result);
512
513 assert_se(chaseat(tfd, "abc", CHASE_AT_RESOLVE_IN_ROOT, NULL, NULL) == -ENOENT);
514 assert_se(chaseat(tfd, "/abc", CHASE_AT_RESOLVE_IN_ROOT, NULL, NULL) == -ENOENT);
515
516 ASSERT_OK(chaseat(tfd, "abc", CHASE_AT_RESOLVE_IN_ROOT | CHASE_NONEXISTENT, &result, NULL));
517 ASSERT_STREQ(result, "usr");
518 result = mfree(result);
519
520 ASSERT_OK(chaseat(tfd, "/abc", CHASE_AT_RESOLVE_IN_ROOT | CHASE_NONEXISTENT, &result, NULL));
521 ASSERT_STREQ(result, "usr");
522 result = mfree(result);
523
524 /* Test that absolute path or not are the same when resolving relative to a directory file
525 * descriptor and that we always get a relative path back. */
526
527 ASSERT_OK(fd = openat(tfd, "def", O_CREAT|O_CLOEXEC, 0700));
528 fd = safe_close(fd);
529 ASSERT_OK(symlinkat("/def", tfd, "qed"));
530 ASSERT_OK(chaseat(tfd, "qed", CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
531 ASSERT_STREQ(result, "def");
532 result = mfree(result);
533 ASSERT_OK(chaseat(tfd, "/qed", CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
534 ASSERT_STREQ(result, "def");
535 result = mfree(result);
536
537 /* Valid directory file descriptor without CHASE_AT_RESOLVE_IN_ROOT should resolve symlinks against
538 * host's root. */
539 assert_se(chaseat(tfd, "/qed", 0, NULL, NULL) == -ENOENT);
540
541 /* Test CHASE_PARENT */
542
543 ASSERT_OK(fd = open_mkdir_at(tfd, "chase", O_CLOEXEC, 0755));
544 ASSERT_OK(symlinkat("/def", fd, "parent"));
545 fd = safe_close(fd);
546
547 /* Make sure that when we chase a symlink parent directory, that we chase the parent directory of the
548 * symlink target and not the symlink itself. But if we add CHASE_NOFOLLOW, we get the parent
549 * directory of the symlink itself. */
550
551 ASSERT_OK(chaseat(tfd, "chase/parent", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT, &result, &fd));
552 ASSERT_OK(faccessat(fd, "def", F_OK, 0));
553 ASSERT_STREQ(result, "def");
554 fd = safe_close(fd);
555 result = mfree(result);
556
557 ASSERT_OK(chaseat(tfd, "chase/parent", CHASE_AT_RESOLVE_IN_ROOT|CHASE_PARENT|CHASE_NOFOLLOW, &result, &fd));
558 ASSERT_OK(faccessat(fd, "parent", F_OK, AT_SYMLINK_NOFOLLOW));
559 ASSERT_STREQ(result, "chase/parent");
560 fd = safe_close(fd);
561 result = mfree(result);
562
563 ASSERT_OK(chaseat(tfd, "chase", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT, &result, &fd));
564 ASSERT_OK(faccessat(fd, "chase", F_OK, 0));
565 ASSERT_STREQ(result, "chase");
566 fd = safe_close(fd);
567 result = mfree(result);
568
569 ASSERT_OK(chaseat(tfd, "/", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
570 ASSERT_STREQ(result, ".");
571 result = mfree(result);
572
573 assert_se(chaseat(tfd, ".", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT, &result, NULL));
574 ASSERT_STREQ(result, ".");
575 result = mfree(result);
576
577 /* Test CHASE_MKDIR_0755 */
578
579 ASSERT_OK(chaseat(tfd, "m/k/d/i/r", CHASE_MKDIR_0755|CHASE_NONEXISTENT, &result, NULL));
580 ASSERT_OK(faccessat(tfd, "m/k/d/i", F_OK, 0));
581 assert_se(RET_NERRNO(faccessat(tfd, "m/k/d/i/r", F_OK, 0)) == -ENOENT);
582 ASSERT_STREQ(result, "m/k/d/i/r");
583 result = mfree(result);
584
585 ASSERT_OK(chaseat(tfd, "m/../q", CHASE_MKDIR_0755|CHASE_NONEXISTENT, &result, NULL));
586 ASSERT_OK(faccessat(tfd, "m", F_OK, 0));
587 assert_se(RET_NERRNO(faccessat(tfd, "q", F_OK, 0)) == -ENOENT);
588 ASSERT_STREQ(result, "q");
589 result = mfree(result);
590
591 assert_se(chaseat(tfd, "i/../p", CHASE_MKDIR_0755|CHASE_NONEXISTENT, NULL, NULL) == -ENOENT);
592
593 /* Test CHASE_EXTRACT_FILENAME */
594
595 ASSERT_OK(chaseat(tfd, "chase/parent", CHASE_AT_RESOLVE_IN_ROOT|CHASE_PARENT|CHASE_NOFOLLOW|CHASE_EXTRACT_FILENAME, &result, &fd));
596 ASSERT_OK(faccessat(fd, result, F_OK, AT_SYMLINK_NOFOLLOW));
597 ASSERT_STREQ(result, "parent");
598 fd = safe_close(fd);
599 result = mfree(result);
600
601 ASSERT_OK(chaseat(tfd, "chase", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT|CHASE_EXTRACT_FILENAME, &result, &fd));
602 ASSERT_OK(faccessat(fd, result, F_OK, 0));
603 ASSERT_STREQ(result, "chase");
604 fd = safe_close(fd);
605 result = mfree(result);
606
607 ASSERT_OK(chaseat(tfd, "/", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT|CHASE_EXTRACT_FILENAME, &result, NULL));
608 ASSERT_STREQ(result, ".");
609 result = mfree(result);
610
611 ASSERT_OK(chaseat(tfd, ".", CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT|CHASE_EXTRACT_FILENAME, &result, NULL));
612 ASSERT_STREQ(result, ".");
613 result = mfree(result);
614
615 ASSERT_OK(chaseat(tfd, NULL, CHASE_PARENT|CHASE_AT_RESOLVE_IN_ROOT|CHASE_EXTRACT_FILENAME, &result, NULL));
616 ASSERT_STREQ(result, ".");
617 result = mfree(result);
618
619 /* Test chase_and_openat() */
620
621 fd = chase_and_openat(tfd, "o/p/e/n/f/i/l/e", CHASE_MKDIR_0755, O_CREAT|O_EXCL|O_CLOEXEC, NULL);
622 ASSERT_OK(fd);
623 ASSERT_OK(fd_verify_regular(fd));
624 fd = safe_close(fd);
625
626 fd = chase_and_openat(tfd, "o/p/e/n/d/i/r", CHASE_MKDIR_0755, O_DIRECTORY|O_CREAT|O_EXCL|O_CLOEXEC, NULL);
627 ASSERT_OK(fd);
628 ASSERT_OK(fd_verify_directory(fd));
629 fd = safe_close(fd);
630
631 fd = chase_and_openat(tfd, NULL, CHASE_PARENT|CHASE_EXTRACT_FILENAME, O_PATH|O_DIRECTORY|O_CLOEXEC, &result);
632 ASSERT_OK(fd);
633 ASSERT_STREQ(result, ".");
634 fd = safe_close(fd);
635 result = mfree(result);
636
637 /* Test chase_and_openatdir() */
638
639 ASSERT_OK(chase_and_opendirat(tfd, "o/p/e/n/d/i", 0, &result, &dir));
640 FOREACH_DIRENT(de, dir, assert_not_reached())
641 ASSERT_STREQ(de->d_name, "r");
642 ASSERT_STREQ(result, "o/p/e/n/d/i");
643 result = mfree(result);
644
645 /* Test chase_and_statat() */
646
647 ASSERT_OK(chase_and_statat(tfd, "o/p", 0, &result, &st));
648 ASSERT_OK(stat_verify_directory(&st));
649 ASSERT_STREQ(result, "o/p");
650 result = mfree(result);
651
652 /* Test chase_and_accessat() */
653
654 ASSERT_OK(chase_and_accessat(tfd, "o/p/e", 0, F_OK, &result));
655 ASSERT_STREQ(result, "o/p/e");
656 result = mfree(result);
657
658 /* Test chase_and_fopenat_unlocked() */
659
660 ASSERT_OK(chase_and_fopenat_unlocked(tfd, "o/p/e/n/f/i/l/e", 0, "re", &result, &f));
661 assert_se(fread(&(char[1]) {}, 1, 1, f) == 0);
662 assert_se(feof(f));
663 f = safe_fclose(f);
664 ASSERT_STREQ(result, "o/p/e/n/f/i/l/e");
665 result = mfree(result);
666
667 /* Test chase_and_unlinkat() */
668
669 ASSERT_OK(chase_and_unlinkat(tfd, "o/p/e/n/f/i/l/e", 0, 0, &result));
670 ASSERT_STREQ(result, "o/p/e/n/f/i/l/e");
671 result = mfree(result);
672
673 /* Test chase_and_open_parent_at() */
674
675 ASSERT_OK(fd = chase_and_open_parent_at(tfd, "chase/parent", CHASE_AT_RESOLVE_IN_ROOT|CHASE_NOFOLLOW, &result));
676 ASSERT_OK(faccessat(fd, result, F_OK, AT_SYMLINK_NOFOLLOW));
677 ASSERT_STREQ(result, "parent");
678 fd = safe_close(fd);
679 result = mfree(result);
680
681 ASSERT_OK(fd = chase_and_open_parent_at(tfd, "chase", CHASE_AT_RESOLVE_IN_ROOT, &result));
682 ASSERT_OK(faccessat(fd, result, F_OK, 0));
683 ASSERT_STREQ(result, "chase");
684 fd = safe_close(fd);
685 result = mfree(result);
686
687 ASSERT_OK(fd = chase_and_open_parent_at(tfd, "/", CHASE_AT_RESOLVE_IN_ROOT, &result));
688 ASSERT_STREQ(result, ".");
689 fd = safe_close(fd);
690 result = mfree(result);
691
692 ASSERT_OK(fd = chase_and_open_parent_at(tfd, ".", CHASE_AT_RESOLVE_IN_ROOT, &result));
693 ASSERT_STREQ(result, ".");
694 fd = safe_close(fd);
695 result = mfree(result);
696}
697
698TEST(chaseat_prefix_root) {
699 _cleanup_free_ char *cwd = NULL, *ret = NULL, *expected = NULL;
700
701 ASSERT_OK(safe_getcwd(&cwd));
702
703 ASSERT_OK(chaseat_prefix_root("/hoge", NULL, &ret));
704 ASSERT_STREQ(ret, "/hoge");
705
706 ret = mfree(ret);
707
708 ASSERT_OK(chaseat_prefix_root("/hoge", "a/b/c", &ret));
709 ASSERT_STREQ(ret, "/hoge");
710
711 ret = mfree(ret);
712
713 ASSERT_OK(chaseat_prefix_root("hoge", "/a/b//./c///", &ret));
714 ASSERT_STREQ(ret, "/a/b/c/hoge");
715
716 ret = mfree(ret);
717
718 ASSERT_OK(chaseat_prefix_root("hoge", "a/b//./c///", &ret));
719 assert_se(expected = path_join(cwd, "a/b/c/hoge"));
720 ASSERT_STREQ(ret, expected);
721
722 ret = mfree(ret);
723 expected = mfree(expected);
724
725 ASSERT_OK(chaseat_prefix_root("./hoge/aaa/../././b", "/a/b//./c///", &ret));
726 ASSERT_STREQ(ret, "/a/b/c/hoge/aaa/../././b");
727
728 ret = mfree(ret);
729
730 assert_se(chaseat_prefix_root("./hoge/aaa/../././b", "a/b//./c///", &ret) >= 0);
731 assert_se(expected = path_join(cwd, "a/b/c/hoge/aaa/../././b"));
732 ASSERT_STREQ(ret, expected);
733}
734
735TEST(trailing_dot_dot) {
736 _cleanup_free_ char *path = NULL, *fdpath = NULL;
737 _cleanup_close_ int fd = -EBADF;
738
739 ASSERT_OK(chase("/usr/..", NULL, CHASE_PARENT, &path, &fd));
740 assert_se(path_equal(path, "/"));
741 ASSERT_OK(fd_get_path(fd, &fdpath));
742 assert_se(path_equal(fdpath, "/"));
743
744 path = mfree(path);
745 fdpath = mfree(fdpath);
746 fd = safe_close(fd);
747
748 _cleanup_(rm_rf_physical_and_freep) char *t = NULL;
749 ASSERT_OK(mkdtemp_malloc(NULL, &t));
750 _cleanup_free_ char *sub = ASSERT_PTR(path_join(t, "a/b/c/d"));
751 ASSERT_OK(mkdir_p(sub, 0700));
752 _cleanup_free_ char *suffixed = ASSERT_PTR(path_join(sub, ".."));
753 ASSERT_OK(chase(suffixed, NULL, CHASE_PARENT, &path, &fd));
754 _cleanup_free_ char *expected1 = ASSERT_PTR(path_join(t, "a/b/c"));
755 _cleanup_free_ char *expected2 = ASSERT_PTR(path_join(t, "a/b"));
756
757 assert_se(path_equal(path, expected1));
758 ASSERT_OK(fd_get_path(fd, &fdpath));
759 assert_se(path_equal(fdpath, expected2));
760}
761
762TEST(use_chase_as_mkdir_p) {
763 _cleanup_free_ char *p = NULL;
764 ASSERT_OK_ERRNO(asprintf(&p, "/tmp/chasemkdir%" PRIu64 "/a/b/c", random_u64()));
765
766 _cleanup_close_ int fd = -EBADF;
767 ASSERT_OK(chase(p, NULL, CHASE_PREFIX_ROOT|CHASE_MKDIR_0755, NULL, &fd));
768
769 ASSERT_OK_EQ(inode_same_at(AT_FDCWD, p, fd, NULL, AT_EMPTY_PATH), 1);
770
771 _cleanup_close_ int fd2 = -EBADF;
772 ASSERT_OK(chase(p, p, CHASE_PREFIX_ROOT|CHASE_MKDIR_0755, NULL, &fd2));
773
774 _cleanup_free_ char *pp = ASSERT_PTR(path_join(p, p));
775
776 ASSERT_OK_EQ(inode_same_at(AT_FDCWD, pp, fd2, NULL, AT_EMPTY_PATH), 1);
777
778 _cleanup_free_ char *f = NULL;
779 ASSERT_OK(path_extract_directory(p, &f));
780
781 _cleanup_free_ char *ff = NULL;
782 ASSERT_OK(path_extract_directory(f, &ff));
783
784 _cleanup_free_ char *fff = NULL;
785 ASSERT_OK(path_extract_directory(ff, &fff));
786
787 ASSERT_OK(rm_rf(fff, REMOVE_PHYSICAL));
788}
789
790static int intro(void) {
791 arg_test_dir = saved_argv[1];
792 return EXIT_SUCCESS;
793}
794
795DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, intro);
Unnamed repository; edit this file 'description' to name the repository.