1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * _xftw - file tree walk the uses expanded stat structure
32 *
33 * int _xftw(path, fn, depth) char *path; int (*fn)(); int depth;
34 *
35 * Given a path name, _xftw starts from the file given by that path
36 * name and visits each file and directory in the tree beneath
37 * that file. If a single file has multiple links within the
38 * structure, it will be visited once for each such link.
39 * For each object visited, fn is called with three arguments.
40 * (*fn) (pathname, statp, ftwflag)
41 * The first contains the path name of the object, the second
42 * contains a pointer to a stat buffer which will usually hold
43 * appropriate information for the object and the third will
44 * contain an integer value giving additional information about
45 *
46 * FTW_F The object is a file for which stat was
47 * successful. It does not guarantee that the
48 * file can actually be read.
49 *
50 * FTW_D The object is a directory for which stat and
51 * open for read were both successful.
52 *
53 * FTW_DNR The object is a directory for which stat
54 * succeeded, but which cannot be read. Because
55 * the directory cannot be read, fn will not be
56 * called for any descendants of this directory.
57 *
58 * FTW_NS Stat failed on the object because of lack of
59 * appropriate permission. This indication will
60 * be given for example for each file in a
61 * directory with read but no execute permission.
62 * Because stat failed, it is not possible to
63 * determine whether this object is a file or a
64 * directory. The stat buffer passed to fn will
65 * contain garbage. Stat failure for any reason
66 * other than lack of permission will be
67 * considered an error and will cause _xftw to stop
68 * and return -1 to its caller.
69 *
70 * If fn returns nonzero, _xftw stops and returns the same value
71 * to its caller. If _xftw gets into other trouble along the way,
72 * it returns -1 and leaves an indication of the cause in errno.
73 *
74 * The third argument to _xftw does not limit the depth to which
75 * _xftw will go. Rather, it limits the depth to which _xftw will
76 * go before it starts recycling file descriptors. In general,
77 * it is necessary to use a file descriptor for each level of the
78 * tree, but they can be recycled for deep trees by saving the
79 * position, closing, re-opening, and seeking. In order to descend
80 * to arbitrary depths, _xftw requires 2 file descriptors to be open
81 * during the call to openat(), therefore if the depth argument
82 * is less than 2 _xftw will not use openat(), and it will fail with
83 * ENAMETOOLONG if it descends to a directory that exceeds PATH_MAX.
84 */
85
86 /*
87 * this interface uses the expanded stat structure and therefore
88 * must have EFT enabled.
89 */
90 #ifdef _STYPES
91 #undef _STYPES
92 #endif
93
94 #include "lint.h"
95 #include <sys/types.h>
96 #include <sys/stat.h>
97 #include <fcntl.h>
98 #include <sys/param.h>
99 #include <dirent.h>
100 #include <errno.h>
101 #include <ftw.h>
102 #include <string.h>
103 #include <stdlib.h>
104 #include <unistd.h>
105
106 struct Var {
107 int level;
108 int odepth;
109 };
110
111 static DIR *nocdopendir(const char *, struct Var *);
112 static int nocdstat(const char *, struct stat *, struct Var *, int);
113 static const char *get_unrooted(const char *);
114 static int fwalk(const char *, int (*)(const char *, const struct stat *, int),
115 int, struct Var *);
116
117 /*ARGSUSED*/
118 int
_xftw(int ver,const char * path,int (* fn)(const char *,const struct stat *,int),int depth)119 _xftw(int ver, const char *path,
120 int (*fn)(const char *, const struct stat *, int), int depth)
121 {
122 struct Var var;
123 int rc;
124
125 var.level = 0;
126 var.odepth = depth;
127 rc = fwalk(path, fn, depth, &var);
128 return (rc);
129 }
130
131 /*
132 * This is the recursive walker.
133 */
134 static int
fwalk(const char * path,int (* fn)(const char *,const struct stat *,int),int depth,struct Var * vp)135 fwalk(const char *path, int (*fn)(const char *, const struct stat *, int),
136 int depth, struct Var *vp)
137 {
138 size_t n;
139 int rc;
140 int save_errno;
141 DIR *dirp;
142 char *subpath;
143 struct stat sb;
144 struct dirent *direntp;
145
146 vp->level++;
147
148 /*
149 * Try to get file status.
150 * If unsuccessful, errno will say why.
151 * It's ok to have a symbolic link that points to
152 * non-existing file. In this case, pass FTW_NS
153 * to a function instead of aborting fwalk() right away.
154 */
155 if (nocdstat(path, &sb, vp, 0) < 0) {
156 #ifdef S_IFLNK
157 save_errno = errno;
158 if ((nocdstat(path, &sb, vp, AT_SYMLINK_NOFOLLOW) != -1) &&
159 ((sb.st_mode & S_IFMT) == S_IFLNK)) {
160 errno = save_errno;
161 return (*fn)(path, &sb, FTW_NS);
162 } else {
163 errno = save_errno;
164 }
165 #endif
166 return (errno == EACCES? (*fn)(path, &sb, FTW_NS): -1);
167 }
168
169 /*
170 * The stat succeeded, so we know the object exists.
171 * If not a directory, call the user function and return.
172 */
173 if ((sb.st_mode & S_IFMT) != S_IFDIR)
174 return ((*fn)(path, &sb, FTW_F));
175
176 /*
177 * The object was a directory.
178 *
179 * Open a file to read the directory
180 */
181 dirp = nocdopendir(path, vp);
182
183 /*
184 * Call the user function, telling it whether
185 * the directory can be read. If it can't be read
186 * call the user function or indicate an error,
187 * depending on the reason it couldn't be read.
188 */
189 if (dirp == NULL)
190 return (errno == EACCES? (*fn)(path, &sb, FTW_DNR): -1);
191
192 /* We could read the directory. Call user function. */
193 rc = (*fn)(path, &sb, FTW_D);
194 if (rc != 0) {
195 (void) closedir(dirp);
196 return (rc);
197 }
198
199 /*
200 * Read the directory one component at a time.
201 * We must ignore "." and "..", but other than that,
202 * just create a path name and call self to check it out.
203 */
204 while (direntp = readdir(dirp)) {
205 long here;
206
207 if (strcmp(direntp->d_name, ".") == 0 ||
208 strcmp(direntp->d_name, "..") == 0)
209 continue;
210
211 /* Create a prefix to which we will append component names */
212 n = strlen(path);
213 subpath = malloc(n + strlen(direntp->d_name) + 2);
214 if (subpath == 0) {
215 (void) closedir(dirp);
216 errno = ENOMEM;
217 return (-1);
218 }
219 (void) strcpy(subpath, path);
220 if (subpath[0] != '\0' && subpath[n-1] != '/')
221 subpath[n++] = '/';
222
223 /* Append component name to the working path */
224 (void) strlcpy(&subpath[n], direntp->d_name, MAXNAMELEN);
225
226 /*
227 * If we are about to exceed our depth,
228 * remember where we are and close a file.
229 */
230 if (depth <= 1) {
231 here = telldir(dirp);
232 if (closedir(dirp) < 0) {
233 free(subpath);
234 return (-1);
235 }
236 }
237
238 /*
239 * Do a recursive call to process the file.
240 * (watch this, sports fans)
241 */
242 rc = fwalk(subpath, fn, depth-1, vp);
243 if (rc != 0) {
244 free(subpath);
245 if (depth > 1)
246 (void) closedir(dirp);
247 return (rc);
248 }
249
250 /*
251 * If we closed the file, try to reopen it.
252 */
253 if (depth <= 1) {
254 dirp = nocdopendir(path, vp);
255 if (dirp == NULL) {
256 free(subpath);
257 return (-1);
258 }
259 seekdir(dirp, here);
260 }
261 free(subpath);
262 }
263 (void) closedir(dirp);
264 return (0);
265 }
266
267 /*
268 * Open a directory with an arbitrarily long path name. If the original
269 * depth arg >= 2, use openat() to make sure that it doesn't fail with
270 * ENAMETOOLONG.
271 */
272 static DIR *
nocdopendir(const char * path,struct Var * vp)273 nocdopendir(const char *path, struct Var *vp)
274 {
275 int fd, cfd;
276 DIR *fdd;
277 char *dirp, *token, *ptr;
278
279 fdd = opendir(path);
280 if ((vp->odepth > 1) && (fdd == NULL) && (errno == ENAMETOOLONG)) {
281 /*
282 * Traverse the path using openat() to get the fd for
283 * fdopendir().
284 */
285 if ((dirp = strdup(path)) == NULL) {
286 errno = ENAMETOOLONG;
287 return (NULL);
288 }
289 if ((token = strtok_r(dirp, "/", &ptr)) != NULL) {
290 if ((fd = openat(AT_FDCWD, dirp, O_RDONLY)) < 0) {
291 (void) free(dirp);
292 errno = ENAMETOOLONG;
293 return (NULL);
294 }
295 while ((token = strtok_r(NULL, "/", &ptr)) != NULL) {
296 if ((cfd = openat(fd, token, O_RDONLY)) < 0) {
297 (void) close(fd);
298 (void) free(dirp);
299 errno = ENAMETOOLONG;
300 return (NULL);
301 }
302 (void) close(fd);
303 fd = cfd;
304 }
305 (void) free(dirp);
306 return (fdopendir(fd));
307 }
308 (void) free(dirp);
309 errno = ENAMETOOLONG;
310 }
311 return (fdd);
312 }
313
314 /*
315 * Stat a file with an arbitrarily long path name. If we aren't doing a
316 * stat on the arg passed to _xftw() and if the original depth arg >= 2,
317 * use openat() to make sure that it doesn't fail with ENAMETOOLONG.
318 */
319 static int
nocdstat(const char * path,struct stat * statp,struct Var * vp,int sym)320 nocdstat(const char *path, struct stat *statp, struct Var *vp, int sym)
321 {
322 int fd, cfd;
323 char *dirp, *token, *ptr;
324 int rc;
325 const char *unrootp;
326 int save_err;
327
328 rc = fstatat(AT_FDCWD, path, statp, sym);
329 if ((vp->level > 1) && (vp->odepth >= 2) && (rc < 0) &&
330 (errno == ENAMETOOLONG)) {
331 /* Traverse path using openat() to get fd for fstatat(). */
332 if ((dirp = strdup(path)) == NULL) {
333 errno = ENAMETOOLONG;
334 return (-1);
335 }
336 if ((token = strtok_r(dirp, "/", &ptr)) != NULL) {
337 if ((fd = openat(AT_FDCWD, dirp, O_RDONLY)) < 0) {
338 (void) free(dirp);
339 errno = ENAMETOOLONG;
340 return (-1);
341 }
342 unrootp = get_unrooted(path);
343 while (((token = strtok_r(NULL, "/", &ptr)) != NULL) &&
344 (strcmp(token, unrootp) != 0)) {
345 if ((cfd = openat(fd, token, O_RDONLY)) < 0) {
346 (void) close(fd);
347 (void) free(dirp);
348 errno = ENAMETOOLONG;
349 return (0);
350 }
351 (void) close(fd);
352 fd = cfd;
353 }
354 (void) free(dirp);
355 rc = fstatat(fd, unrootp, statp, sym);
356 save_err = errno;
357 (void) close(fd);
358 errno = save_err;
359 return (rc);
360 }
361 (void) free(dirp);
362 errno = ENAMETOOLONG;
363 }
364 return (rc);
365 }
366
367 /*
368 * Return pointer basename of path. This routine doesn't remove
369 * trailing slashes, but there won't be any.
370 */
371 static const char *
get_unrooted(const char * path)372 get_unrooted(const char *path)
373 {
374 const char *ptr;
375
376 if (!path || !*path)
377 return (NULL);
378
379 ptr = path + strlen(path);
380 /* find last char in path before any trailing slashes */
381 while (ptr != path && *--ptr == '/')
382 ;
383
384 if (ptr == path) /* all slashes */
385 return (ptr);
386
387 while (ptr != path)
388 if (*--ptr == '/')
389 return (++ptr);
390
391 return (ptr);
392 }
393