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