1/* Test for reading directories with getdents64.
2 Copyright (C) 2019-2024 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19#include <dirent.h>
20#include <errno.h>
21#include <fcntl.h>
22#include <limits.h>
23#include <stdbool.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <support/check.h>
28#include <support/support.h>
29#include <support/xunistd.h>
30#include <sys/mman.h>
31#include <unistd.h>
32
33/* Called by large_buffer_checks below. */
34static void
35large_buffer_check (int fd, char *large_buffer, size_t large_buffer_size)
36{
37 xlseek (fd, offset: 0, SEEK_SET);
38 ssize_t ret = getdents64 (fd: fd, buffer: large_buffer, length: large_buffer_size);
39 if (ret < 0)
40 FAIL_EXIT1 ("getdents64 for buffer of %zu bytes failed: %m",
41 large_buffer_size);
42 if (ret < offsetof (struct dirent64, d_name))
43 FAIL_EXIT1 ("getdents64 for buffer of %zu returned small value %zd",
44 large_buffer_size, ret);
45}
46
47/* Bug 24740: Make sure that the system call argument is adjusted
48 properly for the int type. A large value should stay a large
49 value, and not wrap around to something small, causing the system
50 call to fail with EINVAL. */
51static void
52large_buffer_checks (int fd)
53{
54 size_t large_buffer_size;
55 if (!__builtin_add_overflow (UINT_MAX, 2, &large_buffer_size))
56 {
57 int flags = MAP_ANONYMOUS | MAP_PRIVATE;
58#ifdef MAP_NORESERVE
59 flags |= MAP_NORESERVE;
60#endif
61 void *large_buffer = mmap (NULL, len: large_buffer_size,
62 PROT_READ | PROT_WRITE, flags: flags, fd: -1, offset: 0);
63 if (large_buffer == MAP_FAILED)
64 printf (format: "warning: could not allocate %zu bytes of memory,"
65 " subtests skipped\n", large_buffer_size);
66 else
67 {
68 large_buffer_check (fd, large_buffer, INT_MAX);
69 large_buffer_check (fd, large_buffer, large_buffer_size: (size_t) INT_MAX + 1);
70 large_buffer_check (fd, large_buffer, large_buffer_size: (size_t) INT_MAX + 2);
71 large_buffer_check (fd, large_buffer, UINT_MAX);
72 large_buffer_check (fd, large_buffer, large_buffer_size: (size_t) UINT_MAX + 1);
73 large_buffer_check (fd, large_buffer, large_buffer_size: (size_t) UINT_MAX + 2);
74 xmunmap (addr: large_buffer, length: large_buffer_size);
75 }
76 }
77}
78
79static void
80do_test_large_size (void)
81{
82 int fd = xopen (path: ".", O_RDONLY | O_DIRECTORY, 0);
83 TEST_VERIFY (fd >= 0);
84 large_buffer_checks (fd);
85
86 xclose (fd);
87}
88
89static void
90do_test_by_size (size_t buffer_size)
91{
92 /* The test compares the iteration order with readdir64. */
93 DIR *reference = opendir (name: ".");
94 TEST_VERIFY_EXIT (reference != NULL);
95
96 int fd = xopen (path: ".", O_RDONLY | O_DIRECTORY, 0);
97 TEST_VERIFY (fd >= 0);
98
99 /* Perform two passes, with a rewind operating between passes. */
100 for (int pass = 0; pass < 2; ++pass)
101 {
102 /* Check that we need to fill the buffer multiple times. */
103 int read_count = 0;
104
105 while (true)
106 {
107 /* Simple way to make sure that the memcpy below does not read
108 non-existing data. */
109 struct
110 {
111 char buffer[buffer_size];
112 struct dirent64 pad;
113 } data;
114
115 ssize_t ret = getdents64 (fd: fd, buffer: &data.buffer, length: sizeof (data.buffer));
116 if (ret < 0)
117 FAIL_EXIT1 ("getdents64: %m");
118 if (ret == 0)
119 break;
120 ++read_count;
121
122 char *current = data.buffer;
123 char *end = data.buffer + ret;
124 while (current != end)
125 {
126 struct dirent64 entry;
127 memcpy (&entry, current, sizeof (entry));
128 /* Truncate overlong strings. */
129 entry.d_name[sizeof (entry.d_name) - 1] = '\0';
130 TEST_VERIFY (strlen (entry.d_name) < sizeof (entry.d_name) - 1);
131
132 errno = 0;
133 struct dirent64 *refentry = readdir64 (dirp: reference);
134 if (refentry == NULL && errno == 0)
135 FAIL_EXIT1 ("readdir64 failed too early, at: %s",
136 entry.d_name);
137 else if (refentry == NULL)
138 FAIL_EXIT1 ("readdir64: %m");
139
140 TEST_COMPARE_STRING (entry.d_name, refentry->d_name);
141 TEST_COMPARE (entry.d_ino, refentry->d_ino);
142 TEST_COMPARE (entry.d_off, refentry->d_off);
143 TEST_COMPARE (entry.d_type, refentry->d_type);
144
145 /* Offset zero is reserved for the first entry. */
146 TEST_VERIFY (entry.d_off != 0);
147
148 TEST_VERIFY_EXIT (entry.d_reclen <= end - current);
149 current += entry.d_reclen;
150 }
151 }
152
153 /* We expect to have reached the end of the stream. */
154 errno = 0;
155 TEST_VERIFY (readdir64 (reference) == NULL);
156 TEST_COMPARE (errno, 0);
157
158 /* direntries_read has been called more than once. */
159 TEST_VERIFY (read_count > 0);
160
161 /* Rewind both directory streams. */
162 xlseek (fd, offset: 0, SEEK_SET);
163 rewinddir (dirp: reference);
164 }
165
166 xclose (fd);
167 closedir (dirp: reference);
168}
169
170static int
171do_test (void)
172{
173 do_test_by_size (buffer_size: 512);
174 do_test_by_size (buffer_size: 1024);
175 do_test_by_size (buffer_size: 4096);
176
177 do_test_large_size ();
178
179 return 0;
180}
181
182#include <support/test-driver.c>
183

source code of glibc/sysdeps/unix/sysv/linux/tst-getdents64.c