1 /* Test of rename() function.
2 Copyright (C) 2009-2023 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* This file is designed to test both rename(a,b) and
18 renameat(AT_FDCWD,a,AT_FDCWD,b). FUNC is the function to test.
19 Assumes that BASE and ASSERT are already defined, and that
20 appropriate headers are already included. If PRINT, warn before
21 skipping symlink tests with status 77. */
22
23 /* Tests whether a file, given by a file name without slashes, exists in
24 the current directory, by scanning the directory entries. */
25 static bool
26 dentry_exists (const char *filename)
27 {
28 bool exists = false;
29 DIR *dir = opendir (".");
30
31 ASSERT (dir != NULL);
32 for (;;)
33 {
34 struct dirent *d = readdir (dir);
35 if (d == NULL)
36 break;
37 if (strcmp (d->d_name, filename) == 0)
38 {
39 exists = true;
40 break;
41 }
42 }
43 ASSERT (closedir (dir) == 0);
44 return exists;
45 }
46
47 /* Asserts that a specific file, given by a file name without slashes, does
48 not exist in the current directory. */
49 static void
50 assert_nonexistent (const char *filename)
51 {
52 struct stat st;
53
54 /* The usual way to test the presence of a file is via stat() or lstat(). */
55 errno = 0;
56 if (stat (filename, &st) == -1)
57 ASSERT (errno == ENOENT);
58 else
59 {
60 /* But after renaming a directory over an empty directory on an NFS-
61 mounted file system, on Linux 2.6.18, for a period of 30 seconds the
62 old directory name is "present" according to stat() but "nonexistent"
63 according to dentry_exists(). */
64 ASSERT (!dentry_exists (filename));
65 /* Remove the old directory name, so that subsequent mkdir calls
66 succeed. */
67 (void) rmdir (filename);
68 }
69 }
70
71 static int
72 test_rename (int (*func) (char const *, char const *), bool print)
73 {
74 /* Setup. */
75 struct stat st;
76 int fd = creat (BASE "file", 0600);
77 ASSERT (0 <= fd);
78 ASSERT (write (fd, "hi", 2) == 2);
79 ASSERT (close (fd) == 0);
80 ASSERT (mkdir (BASE "dir", 0700) == 0);
81
82 /* Files present here:
83 {BASE}file
84 {BASE}dir/
85 */
86
87 /* Obvious errors. */
88
89 { /* Missing source. */
90 {
91 errno = 0;
92 ASSERT (func (BASE "missing", BASE "missing") == -1);
93 ASSERT (errno == ENOENT);
94 }
95 {
96 errno = 0;
97 ASSERT (func (BASE "missing/", BASE "missing") == -1);
98 ASSERT (errno == ENOENT);
99 }
100 {
101 errno = 0;
102 ASSERT (func (BASE "missing", BASE "missing/") == -1);
103 ASSERT (errno == ENOENT);
104 }
105 }
106 { /* Empty operand. */
107 {
108 errno = 0;
109 ASSERT (func ("", BASE "missing") == -1);
110 ASSERT (errno == ENOENT);
111 }
112 {
113 errno = 0;
114 ASSERT (func (BASE "file", "") == -1);
115 ASSERT (errno == ENOENT);
116 }
117 {
118 errno = 0;
119 ASSERT (func (BASE "", "") == -1);
120 ASSERT (errno == ENOENT);
121 }
122 }
123
124 /* Files. */
125
126 { /* Trailing slash. */
127 {
128 errno = 0;
129 ASSERT (func (BASE "file", BASE "file2/") == -1);
130 ASSERT (errno == ENOENT || errno == ENOTDIR);
131 }
132 {
133 errno = 0;
134 ASSERT (func (BASE "file/", BASE "file2") == -1);
135 ASSERT (errno == ENOTDIR);
136 }
137 {
138 errno = 0;
139 ASSERT (stat (BASE "file2", &st) == -1);
140 ASSERT (errno == ENOENT);
141 }
142 }
143 { /* Simple rename. */
144 ASSERT (func (BASE "file", BASE "file2") == 0);
145 errno = 0;
146 ASSERT (stat (BASE "file", &st) == -1);
147 ASSERT (errno == ENOENT);
148 memset (&st, 0, sizeof st);
149 ASSERT (stat (BASE "file2", &st) == 0);
150 ASSERT (st.st_size == 2);
151 }
152 /* Files present here:
153 {BASE}file2
154 {BASE}dir/
155 */
156 { /* Overwrite. */
157 ASSERT (close (creat (BASE "file", 0600)) == 0);
158 errno = 0;
159 ASSERT (func (BASE "file2", BASE "file/") == -1);
160 ASSERT (errno == ENOTDIR);
161 ASSERT (func (BASE "file2", BASE "file") == 0);
162 memset (&st, 0, sizeof st);
163 ASSERT (stat (BASE "file", &st) == 0);
164 ASSERT (st.st_size == 2);
165 errno = 0;
166 ASSERT (stat (BASE "file2", &st) == -1);
167 ASSERT (errno == ENOENT);
168 }
169 /* Files present here:
170 {BASE}file
171 {BASE}dir/
172 */
173
174 /* Directories. */
175
176 { /* Simple rename. */
177 {
178 ASSERT (func (BASE "dir", BASE "dir2/") == 0);
179 errno = 0;
180 ASSERT (stat (BASE "dir", &st) == -1);
181 ASSERT (errno == ENOENT);
182 ASSERT (stat (BASE "dir2", &st) == 0);
183 }
184 /* Files present here:
185 {BASE}file
186 {BASE}dir2/
187 */
188 {
189 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
190 ASSERT (stat (BASE "dir", &st) == 0);
191 errno = 0;
192 ASSERT (stat (BASE "dir2", &st) == -1);
193 ASSERT (errno == ENOENT);
194 }
195 /* Files present here:
196 {BASE}file
197 {BASE}dir/
198 */
199 {
200 ASSERT (func (BASE "dir", BASE "dir2") == 0);
201 errno = 0;
202 ASSERT (stat (BASE "dir", &st) == -1);
203 ASSERT (errno == ENOENT);
204 ASSERT (stat (BASE "dir2", &st) == 0);
205 }
206 /* Files present here:
207 {BASE}file
208 {BASE}dir2/
209 */
210 { /* Empty onto empty. */
211 ASSERT (mkdir (BASE "dir", 0700) == 0);
212 /* Files present here:
213 {BASE}file
214 {BASE}dir/
215 {BASE}dir2/
216 */
217 ASSERT (func (BASE "dir2", BASE "dir") == 0);
218 /* Files present here:
219 {BASE}file
220 {BASE}dir/
221 */
222 ASSERT (mkdir (BASE "dir2", 0700) == 0);
223 /* Files present here:
224 {BASE}file
225 {BASE}dir/
226 {BASE}dir2/
227 */
228 ASSERT (func (BASE "dir2", BASE "dir/") == 0);
229 /* Files present here:
230 {BASE}file
231 {BASE}dir/
232 */
233 ASSERT (mkdir (BASE "dir2", 0700) == 0);
234 /* Files present here:
235 {BASE}file
236 {BASE}dir/
237 {BASE}dir2/
238 */
239 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
240 /* Files present here:
241 {BASE}file
242 {BASE}dir/
243 */
244 ASSERT (mkdir (BASE "dir2", 0700) == 0);
245 }
246 /* Files present here:
247 {BASE}file
248 {BASE}dir/
249 {BASE}dir2/
250 */
251 { /* Empty onto full. */
252 ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
253 /* Files present here:
254 {BASE}file
255 {BASE}dir/
256 {BASE}dir/file
257 {BASE}dir2/
258 */
259 {
260 errno = 0;
261 ASSERT (func (BASE "dir2", BASE "dir") == -1);
262 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
263 }
264 {
265 errno = 0;
266 ASSERT (func (BASE "dir2/", BASE "dir") == -1);
267 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
268 }
269 {
270 errno = 0;
271 ASSERT (func (BASE "dir2", BASE "dir/") == -1);
272 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
273 }
274 }
275 { /* Full onto empty. */
276 ASSERT (func (BASE "dir", BASE "dir2") == 0);
277 assert_nonexistent (BASE "dir");
278 ASSERT (stat (BASE "dir2/file", &st) == 0);
279 /* Files present here:
280 {BASE}file
281 {BASE}dir2/
282 {BASE}dir2/file
283 */
284 ASSERT (mkdir (BASE "dir", 0700) == 0);
285 /* Files present here:
286 {BASE}file
287 {BASE}dir/
288 {BASE}dir2/
289 {BASE}dir2/file
290 */
291 {
292 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
293 ASSERT (stat (BASE "dir/file", &st) == 0);
294 errno = 0;
295 ASSERT (stat (BASE "dir2", &st) == -1);
296 ASSERT (errno == ENOENT);
297 }
298 /* Files present here:
299 {BASE}file
300 {BASE}dir/
301 {BASE}dir/file
302 */
303 ASSERT (mkdir (BASE "dir2", 0700) == 0);
304 /* Files present here:
305 {BASE}file
306 {BASE}dir/
307 {BASE}dir/file
308 {BASE}dir2/
309 */
310 {
311 ASSERT (func (BASE "dir", BASE "dir2/") == 0);
312 assert_nonexistent (BASE "dir");
313 ASSERT (stat (BASE "dir2/file", &st) == 0);
314 }
315 /* Files present here:
316 {BASE}file
317 {BASE}dir2/
318 {BASE}dir2/file
319 */
320 ASSERT (unlink (BASE "dir2/file") == 0);
321 }
322 /* Files present here:
323 {BASE}file
324 {BASE}dir2/
325 */
326 { /* Reject trailing dot. */
327 {
328 errno = 0;
329 ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
330 ASSERT (errno == EINVAL || errno == ENOENT);
331 }
332 ASSERT (mkdir (BASE "dir", 0700) == 0);
333 /* Files present here:
334 {BASE}file
335 {BASE}dir/
336 {BASE}dir2/
337 */
338 {
339 errno = 0;
340 ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
341 ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
342 || errno == ENOTEMPTY || errno == EEXIST
343 || errno == ENOENT /* WSL */);
344 }
345 {
346 errno = 0;
347 ASSERT (func (BASE "dir2/.", BASE "dir") == -1);
348 ASSERT (errno == EINVAL || errno == EBUSY || errno == EEXIST
349 || errno == ENOENT /* WSL */);
350 }
351 ASSERT (rmdir (BASE "dir") == 0);
352 /* Files present here:
353 {BASE}file
354 {BASE}dir2/
355 */
356 {
357 errno = 0;
358 ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
359 ASSERT (errno == EINVAL || errno == ENOENT);
360 }
361 ASSERT (mkdir (BASE "dir", 0700) == 0);
362 /* Files present here:
363 {BASE}file
364 {BASE}dir/
365 {BASE}dir2/
366 */
367 {
368 errno = 0;
369 ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
370 ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
371 || errno == ENOTEMPTY || errno == EEXIST
372 || errno == ENOENT /* WSL */);
373 }
374 {
375 errno = 0;
376 ASSERT (func (BASE "dir2/.//", BASE "dir") == -1);
377 ASSERT (errno == EINVAL || errno == EBUSY || errno == EEXIST
378 || errno == ENOENT /* WSL */);
379 }
380 ASSERT (rmdir (BASE "dir2") == 0);
381 /* Files present here:
382 {BASE}file
383 {BASE}dir/
384 */
385 }
386 { /* Move into subdir. */
387 {
388 errno = 0;
389 ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
390 ASSERT (errno == EINVAL || errno == EACCES);
391 }
392 {
393 errno = 0;
394 ASSERT (stat (BASE "dir/sub", &st) == -1);
395 ASSERT (errno == ENOENT);
396 }
397 ASSERT (mkdir (BASE "dir/sub", 0700) == 0);
398 /* Files present here:
399 {BASE}file
400 {BASE}dir/
401 {BASE}dir/sub/
402 */
403 {
404 errno = 0;
405 ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
406 ASSERT (errno == EINVAL);
407 ASSERT (stat (BASE "dir/sub", &st) == 0);
408 }
409 ASSERT (rmdir (BASE "dir/sub") == 0);
410 }
411 }
412 /* Files present here:
413 {BASE}file
414 {BASE}dir/
415 */
416
417 /* Mixing file and directory. */
418
419 {
420 { /* File onto dir. */
421 {
422 errno = 0;
423 ASSERT (func (BASE "file", BASE "dir") == -1);
424 ASSERT (errno == EISDIR || errno == ENOTDIR);
425 }
426 {
427 errno = 0;
428 ASSERT (func (BASE "file", BASE "dir/") == -1);
429 ASSERT (errno == EISDIR || errno == ENOTDIR);
430 }
431 }
432 { /* Dir onto file. */
433 {
434 errno = 0;
435 ASSERT (func (BASE "dir", BASE "file") == -1);
436 ASSERT (errno == ENOTDIR);
437 }
438 {
439 errno = 0;
440 ASSERT (func (BASE "dir/", BASE "file") == -1);
441 ASSERT (errno == ENOTDIR);
442 }
443 }
444 }
445
446 /* Hard links. */
447
448 { /* File onto self. */
449 ASSERT (func (BASE "file", BASE "file") == 0);
450 memset (&st, 0, sizeof st);
451 ASSERT (stat (BASE "file", &st) == 0);
452 ASSERT (st.st_size == 2);
453 }
454 /* Files present here:
455 {BASE}file
456 {BASE}dir/
457 */
458 { /* Empty dir onto self. */
459 ASSERT (func (BASE "dir", BASE "dir") == 0);
460 ASSERT (stat (BASE "dir", &st) == 0);
461 }
462 /* Files present here:
463 {BASE}file
464 {BASE}dir/
465 */
466 ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
467 /* Files present here:
468 {BASE}file
469 {BASE}dir/
470 {BASE}dir/file
471 */
472 { /* Full dir onto self. */
473 ASSERT (func (BASE "dir", BASE "dir") == 0);
474 }
475 ASSERT (unlink (BASE "dir/file") == 0);
476 /* Files present here:
477 {BASE}file
478 {BASE}dir/
479 */
480 {
481 /* Not all file systems support link. Mingw doesn't have
482 reliable st_nlink on hard links, but our implementation does
483 fail with EPERM on poor file systems, and we can detect the
484 inferior stat() via st_ino. Cygwin 1.5.x copies rather than
485 links files on those file systems, but there, st_nlink and
486 st_ino are reliable. */
487 int ret = link (BASE "file", BASE "file2");
488 if (!ret)
489 {
490 memset (&st, 0, sizeof st);
491 ASSERT (stat (BASE "file2", &st) == 0);
492 if (st.st_ino && st.st_nlink != 2)
493 {
494 ASSERT (unlink (BASE "file2") == 0);
495 errno = EPERM;
496 ret = -1;
497 }
498 }
499 if (ret == -1)
500 {
501 /* If the device does not support hard links, errno is
502 EPERM on Linux,
503 EOPNOTSUPP on FreeBSD,
504 EACCES on Android within Termux. */
505 switch (errno)
506 {
507 case EPERM:
508 case EOPNOTSUPP:
509 #if defined __ANDROID__
510 case EACCES:
511 #endif
512 if (print)
513 fputs ("skipping test: "
514 "hard links not supported on this file system\n",
515 stderr);
516 ASSERT (unlink (BASE "file") == 0);
517 ASSERT (rmdir (BASE "dir") == 0);
518 return 77;
519 default:
520 perror ("link");
521 return 1;
522 }
523 }
524 ASSERT (ret == 0);
525 }
526 /* Files present here:
527 {BASE}file
528 {BASE}file2 (hard link to file)
529 {BASE}dir/
530 */
531 { /* File onto hard link. */
532 ASSERT (func (BASE "file", BASE "file2") == 0);
533 memset (&st, 0, sizeof st);
534 if (stat (BASE "file", &st) != 0)
535 {
536 /* This can happen on NetBSD. */
537 ASSERT (errno == ENOENT);
538 ASSERT (link (BASE "file2", BASE "file") == 0);
539 ASSERT (stat (BASE "file", &st) == 0);
540 }
541 ASSERT (st.st_size == 2);
542 memset (&st, 0, sizeof st);
543 ASSERT (stat (BASE "file2", &st) == 0);
544 ASSERT (st.st_size == 2);
545 }
546 /* Files present here:
547 {BASE}file
548 {BASE}file2
549 {BASE}dir/
550 */
551 ASSERT (unlink (BASE "file2") == 0);
552 /* Files present here:
553 {BASE}file
554 {BASE}dir/
555 */
556
557 /* Symlinks. */
558
559 if (symlink (BASE "file", BASE "link1"))
560 {
561 if (print)
562 fputs ("skipping test: symlinks not supported on this file system\n",
563 stderr);
564 ASSERT (unlink (BASE "file") == 0);
565 ASSERT (rmdir (BASE "dir") == 0);
566 return 77;
567 }
568 /* Files present here:
569 {BASE}file
570 {BASE}link1 -> {BASE}file
571 {BASE}dir/
572 */
573 { /* Simple rename. */
574 ASSERT (func (BASE "link1", BASE "link2") == 0);
575 ASSERT (stat (BASE "file", &st) == 0);
576 errno = 0;
577 ASSERT (lstat (BASE "link1", &st) == -1);
578 ASSERT (errno == ENOENT);
579 memset (&st, 0, sizeof st);
580 ASSERT (lstat (BASE "link2", &st) == 0);
581 ASSERT (S_ISLNK (st.st_mode));
582 }
583 /* Files present here:
584 {BASE}file
585 {BASE}link2 -> {BASE}file
586 {BASE}dir/
587 */
588 { /* Overwrite. */
589 ASSERT (symlink (BASE "nowhere", BASE "link1") == 0);
590 /* Files present here:
591 {BASE}file
592 {BASE}link1 -> {BASE}nowhere
593 {BASE}link2 -> {BASE}file
594 {BASE}dir/
595 */
596 {
597 ASSERT (func (BASE "link2", BASE "link1") == 0);
598 memset (&st, 0, sizeof st);
599 ASSERT (stat (BASE "link1", &st) == 0);
600 ASSERT (st.st_size == 2);
601 errno = 0;
602 ASSERT (lstat (BASE "link2", &st) == -1);
603 ASSERT (errno == ENOENT);
604 }
605 }
606 /* Files present here:
607 {BASE}file
608 {BASE}link1 -> {BASE}file
609 {BASE}dir/
610 */
611 { /* Symlink loop. */
612 ASSERT (symlink (BASE "link2", BASE "link2") == 0);
613 /* Files present here:
614 {BASE}file
615 {BASE}link1 -> {BASE}file
616 {BASE}link2 -> {BASE}link2
617 {BASE}dir/
618 */
619 {
620 ASSERT (func (BASE "link2", BASE "link2") == 0);
621 }
622 {
623 errno = 0;
624 ASSERT (func (BASE "link2/", BASE "link2") == -1);
625 ASSERT (errno == ELOOP || errno == ENOTDIR);
626 }
627 ASSERT (func (BASE "link2", BASE "link3") == 0);
628 /* Files present here:
629 {BASE}file
630 {BASE}link1 -> {BASE}file
631 {BASE}link3 -> {BASE}link2
632 {BASE}dir/
633 */
634 ASSERT (unlink (BASE "link3") == 0);
635 }
636 /* Files present here:
637 {BASE}file
638 {BASE}link1 -> {BASE}file
639 {BASE}dir/
640 */
641 { /* Dangling link. */
642 ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
643 /* Files present here:
644 {BASE}file
645 {BASE}link1 -> {BASE}file
646 {BASE}link2 -> {BASE}nowhere
647 {BASE}dir/
648 */
649 {
650 ASSERT (func (BASE "link2", BASE "link3") == 0);
651 errno = 0;
652 ASSERT (lstat (BASE "link2", &st) == -1);
653 ASSERT (errno == ENOENT);
654 memset (&st, 0, sizeof st);
655 ASSERT (lstat (BASE "link3", &st) == 0);
656 }
657 }
658 /* Files present here:
659 {BASE}file
660 {BASE}link1 -> {BASE}file
661 {BASE}link3 -> {BASE}nowhere
662 {BASE}dir/
663 */
664 { /* Trailing slash on dangling. */
665 {
666 errno = 0;
667 ASSERT (func (BASE "link3/", BASE "link2") == -1);
668 ASSERT (errno == ENOENT || errno == ENOTDIR);
669 }
670 {
671 errno = 0;
672 ASSERT (func (BASE "link3", BASE "link2/") == -1);
673 ASSERT (errno == ENOENT || errno == ENOTDIR);
674 }
675 {
676 errno = 0;
677 ASSERT (lstat (BASE "link2", &st) == -1);
678 ASSERT (errno == ENOENT);
679 }
680 memset (&st, 0, sizeof st);
681 ASSERT (lstat (BASE "link3", &st) == 0);
682 }
683 /* Files present here:
684 {BASE}file
685 {BASE}link1 -> {BASE}file
686 {BASE}link3 -> {BASE}nowhere
687 {BASE}dir/
688 */
689 { /* Trailing slash on link to file. */
690 {
691 errno = 0;
692 ASSERT (func (BASE "link1/", BASE "link2") == -1);
693 ASSERT (errno == ENOTDIR);
694 }
695 {
696 errno = 0;
697 ASSERT (func (BASE "link1", BASE "link3/") == -1);
698 ASSERT (errno == ENOENT || errno == ENOTDIR);
699 }
700 }
701 /* Files present here:
702 {BASE}file
703 {BASE}link1 -> {BASE}file
704 {BASE}link3 -> {BASE}nowhere
705 {BASE}dir/
706 */
707
708 /* Mixing symlink and file. */
709
710 { /* File onto link. */
711 ASSERT (close (creat (BASE "file2", 0600)) == 0);
712 /* Files present here:
713 {BASE}file
714 {BASE}file2
715 {BASE}link1 -> {BASE}file
716 {BASE}link3 -> {BASE}nowhere
717 {BASE}dir/
718 */
719 {
720 ASSERT (func (BASE "file2", BASE "link3") == 0);
721 errno = 0;
722 ASSERT (stat (BASE "file2", &st) == -1);
723 ASSERT (errno == ENOENT);
724 memset (&st, 0, sizeof st);
725 ASSERT (lstat (BASE "link3", &st) == 0);
726 ASSERT (S_ISREG (st.st_mode));
727 }
728 /* Files present here:
729 {BASE}file
730 {BASE}link1 -> {BASE}file
731 {BASE}link3
732 {BASE}dir/
733 */
734 ASSERT (unlink (BASE "link3") == 0);
735 }
736 /* Files present here:
737 {BASE}file
738 {BASE}link1 -> {BASE}file
739 {BASE}dir/
740 */
741 { /* Link onto file. */
742 ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
743 /* Files present here:
744 {BASE}file
745 {BASE}link1 -> {BASE}file
746 {BASE}link2 -> {BASE}nowhere
747 {BASE}dir/
748 */
749 ASSERT (close (creat (BASE "file2", 0600)) == 0);
750 /* Files present here:
751 {BASE}file
752 {BASE}file2
753 {BASE}link1 -> {BASE}file
754 {BASE}link2 -> {BASE}nowhere
755 {BASE}dir/
756 */
757 {
758 ASSERT (func (BASE "link2", BASE "file2") == 0);
759 errno = 0;
760 ASSERT (lstat (BASE "link2", &st) == -1);
761 ASSERT (errno == ENOENT);
762 memset (&st, 0, sizeof st);
763 ASSERT (lstat (BASE "file2", &st) == 0);
764 ASSERT (S_ISLNK (st.st_mode));
765 }
766 /* Files present here:
767 {BASE}file
768 {BASE}file2 -> {BASE}nowhere
769 {BASE}link1 -> {BASE}file
770 {BASE}dir/
771 */
772 ASSERT (unlink (BASE "file2") == 0);
773 }
774 /* Files present here:
775 {BASE}file
776 {BASE}link1 -> {BASE}file
777 {BASE}dir/
778 */
779 { /* Trailing slash. */
780 {
781 errno = 0;
782 ASSERT (func (BASE "file/", BASE "link1") == -1);
783 ASSERT (errno == ENOTDIR);
784 }
785 {
786 errno = 0;
787 ASSERT (func (BASE "file", BASE "link1/") == -1);
788 ASSERT (errno == ENOTDIR || errno == ENOENT);
789 }
790 {
791 errno = 0;
792 ASSERT (func (BASE "link1/", BASE "file") == -1);
793 ASSERT (errno == ENOTDIR);
794 }
795 {
796 errno = 0;
797 ASSERT (func (BASE "link1", BASE "file/") == -1);
798 ASSERT (errno == ENOTDIR || errno == ENOENT);
799 memset (&st, 0, sizeof st);
800 ASSERT (lstat (BASE "file", &st) == 0);
801 ASSERT (S_ISREG (st.st_mode));
802 memset (&st, 0, sizeof st);
803 ASSERT (lstat (BASE "link1", &st) == 0);
804 ASSERT (S_ISLNK (st.st_mode));
805 }
806 }
807 /* Files present here:
808 {BASE}file
809 {BASE}link1 -> {BASE}file
810 {BASE}dir/
811 */
812
813 /* Mixing symlink and directory. */
814
815 { /* Directory onto link. */
816 {
817 errno = 0;
818 ASSERT (func (BASE "dir", BASE "link1") == -1);
819 ASSERT (errno == ENOTDIR);
820 }
821 {
822 errno = 0;
823 ASSERT (func (BASE "dir/", BASE "link1") == -1);
824 ASSERT (errno == ENOTDIR);
825 }
826 {
827 errno = 0;
828 ASSERT (func (BASE "dir", BASE "link1/") == -1);
829 ASSERT (errno == ENOTDIR);
830 }
831 }
832 { /* Link onto directory. */
833 {
834 errno = 0;
835 ASSERT (func (BASE "link1", BASE "dir") == -1);
836 ASSERT (errno == EISDIR || errno == ENOTDIR);
837 }
838 {
839 errno = 0;
840 ASSERT (func (BASE "link1", BASE "dir/") == -1);
841 ASSERT (errno == EISDIR || errno == ENOTDIR);
842 }
843 {
844 errno = 0;
845 ASSERT (func (BASE "link1/", BASE "dir") == -1);
846 ASSERT (errno == ENOTDIR);
847 memset (&st, 0, sizeof st);
848 ASSERT (lstat (BASE "link1", &st) == 0);
849 ASSERT (S_ISLNK (st.st_mode));
850 memset (&st, 0, sizeof st);
851 ASSERT (lstat (BASE "dir", &st) == 0);
852 ASSERT (S_ISDIR (st.st_mode));
853 }
854 }
855 /* Files present here:
856 {BASE}file
857 {BASE}link1 -> {BASE}file
858 {BASE}dir/
859 */
860
861 /* POSIX requires rename("link-to-dir/","other") to rename "dir" and
862 leave "link-to-dir" dangling, but GNU rejects this. POSIX
863 requires rename("dir","dangling/") to create the directory so
864 that "dangling/" now resolves, but GNU rejects this. While we
865 prefer GNU behavior, we don't enforce it. However, we do test
866 that the system either follows POSIX in both cases, or follows
867 GNU. */
868 {
869 int result;
870 ASSERT (symlink (BASE "dir2", BASE "link2") == 0);
871 /* Files present here:
872 {BASE}file
873 {BASE}link1 -> {BASE}file
874 {BASE}link2 -> {BASE}dir2
875 {BASE}dir/
876 */
877 errno = 0;
878 result = func (BASE "dir", BASE "link2/");
879 if (result == 0)
880 {
881 /* POSIX. */
882 errno = 0;
883 ASSERT (lstat (BASE "dir", &st) == -1);
884 ASSERT (errno == ENOENT);
885 memset (&st, 0, sizeof st);
886 ASSERT (lstat (BASE "dir2", &st) == 0);
887 ASSERT (S_ISDIR (st.st_mode));
888 memset (&st, 0, sizeof st);
889 ASSERT (lstat (BASE "link2", &st) == 0);
890 ASSERT (S_ISLNK (st.st_mode));
891 /* Files present here:
892 {BASE}file
893 {BASE}link1 -> {BASE}file
894 {BASE}link2 -> {BASE}dir2
895 {BASE}dir2/
896 */
897 {
898 ASSERT (func (BASE "link2/", BASE "dir") == 0);
899 memset (&st, 0, sizeof st);
900 ASSERT (lstat (BASE "dir", &st) == 0);
901 ASSERT (S_ISDIR (st.st_mode));
902 errno = 0;
903 ASSERT (lstat (BASE "dir2", &st) == -1);
904 ASSERT (errno == ENOENT);
905 memset (&st, 0, sizeof st);
906 ASSERT (lstat (BASE "link2", &st) == 0);
907 ASSERT (S_ISLNK (st.st_mode));
908 }
909 }
910 else
911 {
912 /* GNU. */
913 ASSERT (result == -1);
914 ASSERT (errno == ENOTDIR);
915 memset (&st, 0, sizeof st);
916 ASSERT (lstat (BASE "dir", &st) == 0);
917 ASSERT (S_ISDIR (st.st_mode));
918 errno = 0;
919 ASSERT (lstat (BASE "dir2", &st) == -1);
920 ASSERT (errno == ENOENT);
921 memset (&st, 0, sizeof st);
922 ASSERT (lstat (BASE "link2", &st) == 0);
923 ASSERT (S_ISLNK (st.st_mode));
924 ASSERT (unlink (BASE "link2") == 0);
925 ASSERT (symlink (BASE "dir", BASE "link2") == 0);
926 /* Files present here:
927 {BASE}file
928 {BASE}link1 -> {BASE}file
929 {BASE}link2 -> {BASE}dir
930 {BASE}dir/
931 */
932 errno = 0; /* OpenBSD notices that link2/ and dir are the same. */
933 result = func (BASE "link2/", BASE "dir");
934 if (result) /* GNU/Linux rejects attempts to use link2/. */
935 {
936 ASSERT (result == -1);
937 ASSERT (errno == ENOTDIR || errno == EISDIR);
938 }
939 memset (&st, 0, sizeof st);
940 ASSERT (lstat (BASE "dir", &st) == 0);
941 ASSERT (S_ISDIR (st.st_mode));
942 errno = 0;
943 ASSERT (lstat (BASE "dir2", &st) == -1);
944 ASSERT (errno == ENOENT);
945 memset (&st, 0, sizeof st);
946 ASSERT (lstat (BASE "link2", &st) == 0);
947 ASSERT (S_ISLNK (st.st_mode));
948 }
949 }
950 /* Files present here:
951 {BASE}file
952 {BASE}link1 -> {BASE}file
953 {BASE}link2 -> {BASE}dir or {BASE}dir2
954 {BASE}dir/
955 */
956
957 /* Clean up. */
958 ASSERT (unlink (BASE "file") == 0);
959 ASSERT (rmdir (BASE "dir") == 0);
960 ASSERT (unlink (BASE "link1") == 0);
961 ASSERT (unlink (BASE "link2") == 0);
962
963 return 0;
964 }