1 /* Test of getcwd() function.
2 Copyright (C) 2009-2021 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 #include <config.h>
18
19 #include <unistd.h>
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <limits.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/stat.h>
28
29 #include "pathmax.h"
30 #include "macros.h"
31
32 #if !(HAVE_GETPAGESIZE || defined getpagesize)
33 # define getpagesize() 0
34 #endif
35
36 /* This size is chosen to be larger than PATH_MAX (4k), yet smaller than
37 the 16kB pagesize on ia64 linux. Those conditions make the code below
38 trigger a bug in glibc's getcwd implementation before 2.4.90-10. */
39 #define TARGET_LEN (5 * 1024)
40
41 #if defined HAVE_OPENAT || (defined GNULIB_OPENAT && defined HAVE_FDOPENDIR)
42 # define HAVE_OPENAT_SUPPORT 1
43 #else
44 # define HAVE_OPENAT_SUPPORT 0
45 #endif
46
47 /* Keep this test in sync with m4/getcwd-abort-bug.m4. */
48 static int
49 test_abort_bug (void)
50 {
51 char *cwd;
52 size_t initial_cwd_len;
53 int fail = 0;
54
55 /* The bug is triggered when PATH_MAX < getpagesize (), so skip
56 this relatively expensive and invasive test if that's not true. */
57 #ifdef PATH_MAX
58 int bug_possible = PATH_MAX < getpagesize ();
59 #else
60 int bug_possible = 0;
61 #endif
62 if (! bug_possible)
63 return 0;
64
65 cwd = getcwd (NULL, 0);
66 if (cwd == NULL)
67 return 2;
68
69 initial_cwd_len = strlen (cwd);
70 free (cwd);
71
72 if (HAVE_OPENAT_SUPPORT)
73 {
74 static char const dir_name[] = "confdir-14B---";
75 size_t desired_depth = ((TARGET_LEN - 1 - initial_cwd_len)
76 / sizeof dir_name);
77 size_t d;
78 for (d = 0; d < desired_depth; d++)
79 {
80 if (mkdir (dir_name, S_IRWXU) < 0 || chdir (dir_name) < 0)
81 {
82 if (! (errno == ERANGE || errno == ENAMETOOLONG
83 || errno == ENOENT))
84 fail = 3; /* Unable to construct deep hierarchy. */
85 break;
86 }
87 }
88
89 /* If libc has the bug in question, this invocation of getcwd
90 results in a failed assertion. */
91 cwd = getcwd (NULL, 0);
92 if (cwd == NULL)
93 fail = 4; /* getcwd didn't assert, but it failed for a long name
94 where the answer could have been learned. */
95 free (cwd);
96
97 /* Call rmdir first, in case the above chdir failed. */
98 rmdir (dir_name);
99 while (0 < d--)
100 {
101 if (chdir ("..") < 0)
102 {
103 fail = 5;
104 break;
105 }
106 rmdir (dir_name);
107 }
108 }
109
110 return fail;
111 }
112
113 /* The length of this name must be 8. */
114 #define DIR_NAME "confdir3"
115 #define DIR_NAME_LEN 8
116 #define DIR_NAME_SIZE (DIR_NAME_LEN + 1)
117
118 /* The length of "../". */
119 #define DOTDOTSLASH_LEN 3
120
121 /* Leftover bytes in the buffer, to work around library or OS bugs. */
122 #define BUF_SLOP 20
123
124 /* Keep this test in sync with m4/getcwd-path-max.m4. */
125 static int
126 test_long_name (void)
127 {
128 #ifndef PATH_MAX
129 /* The Hurd doesn't define this, so getcwd can't exhibit the bug --
130 at least not on a local file system. And if we were to start worrying
131 about remote file systems, we'd have to enable the wrapper function
132 all of the time, just to be safe. That's not worth the cost. */
133 return 0;
134 #elif ((INT_MAX / (DIR_NAME_SIZE / DOTDOTSLASH_LEN + 1) \
135 - DIR_NAME_SIZE - BUF_SLOP) \
136 <= PATH_MAX)
137 /* FIXME: Assuming there's a system for which this is true,
138 this should be done in a compile test. */
139 return 0;
140 #else
141 char buf[PATH_MAX * (DIR_NAME_SIZE / DOTDOTSLASH_LEN + 1)
142 + DIR_NAME_SIZE + BUF_SLOP];
143 char *cwd = getcwd (buf, PATH_MAX);
144 size_t initial_cwd_len;
145 size_t cwd_len;
146 int fail = 0;
147 size_t n_chdirs = 0;
148
149 if (cwd == NULL)
150 return 1;
151
152 cwd_len = initial_cwd_len = strlen (cwd);
153
154 while (1)
155 {
156 # ifdef HAVE_GETCWD_SHORTER
157 /* On OS/X <= 10.9 for example, we're restricted to shorter paths
158 as lstat() doesn't support more than PATH_MAX. */
159 size_t dotdot_max = PATH_MAX * 2;
160 # else
161 size_t dotdot_max = PATH_MAX * (DIR_NAME_SIZE / DOTDOTSLASH_LEN);
162 # endif
163 char *c = NULL;
164
165 cwd_len += DIR_NAME_SIZE;
166 /* If mkdir or chdir fails, it could be that this system cannot create
167 any file with an absolute name longer than PATH_MAX, such as cygwin.
168 If so, leave fail as 0, because the current working directory can't
169 be too long for getcwd if it can't even be created. On Linux with
170 the 9p file system, mkdir fails with error EINVAL when cwd_len gets
171 too long; ignore this failure because the getcwd() system call
172 produces good results whereas the gnulib substitute calls getdents64
173 which fails with error EPROTO.
174 For other errors, be pessimistic and consider that as a failure,
175 too. */
176 if (mkdir (DIR_NAME, S_IRWXU) < 0 || chdir (DIR_NAME) < 0)
177 {
178 if (! (errno == ERANGE || errno == ENAMETOOLONG || errno == ENOENT))
179 #ifdef __linux__
180 if (! (errno == EINVAL))
181 #endif
182 fail = 2;
183 break;
184 }
185
186 if (PATH_MAX <= cwd_len && cwd_len < PATH_MAX + DIR_NAME_SIZE)
187 {
188 c = getcwd (buf, PATH_MAX);
189 if (!c && errno == ENOENT)
190 {
191 fail = 3;
192 break;
193 }
194 if (c)
195 {
196 fail = 4;
197 break;
198 }
199 if (! (errno == ERANGE || errno == ENAMETOOLONG))
200 {
201 fail = 5;
202 break;
203 }
204 }
205
206 if (dotdot_max <= cwd_len - initial_cwd_len)
207 {
208 if (dotdot_max + DIR_NAME_SIZE < cwd_len - initial_cwd_len)
209 break;
210 c = getcwd (buf, cwd_len + 1);
211 if (!c)
212 {
213 if (! (errno == ERANGE || errno == ENOENT
214 || errno == ENAMETOOLONG))
215 {
216 fail = 6;
217 break;
218 }
219 if (HAVE_OPENAT_SUPPORT || errno == ERANGE || errno == ENOENT)
220 {
221 fail = 7;
222 break;
223 }
224 }
225 }
226
227 if (c && strlen (c) != cwd_len)
228 {
229 fail = 8;
230 break;
231 }
232 ++n_chdirs;
233 }
234
235 /* Leaving behind such a deep directory is not polite.
236 So clean up here, right away, even though the driving
237 shell script would also clean up. */
238 {
239 size_t i;
240
241 /* Try rmdir first, in case the chdir failed. */
242 rmdir (DIR_NAME);
243 for (i = 0; i <= n_chdirs; i++)
244 {
245 if (chdir ("..") < 0)
246 break;
247 if (rmdir (DIR_NAME) != 0)
248 break;
249 }
250 }
251
252 return fail;
253 #endif
254 }
255
256 int
257 main (int argc, char **argv)
258 {
259 return test_abort_bug () * 10 + test_long_name ();
260 }