X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/1c15e88899094343f75aeba04122cd96a96b428e..af359dea2e5ab3e937b62107ecd6a51d78189ed7:/usr/src/lib/libc/gen/fts.c diff --git a/usr/src/lib/libc/gen/fts.c b/usr/src/lib/libc/gen/fts.c index 2a3ede08f2..e2958d3cb4 100644 --- a/usr/src/lib/libc/gen/fts.c +++ b/usr/src/lib/libc/gen/fts.c @@ -2,60 +2,68 @@ * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * - * Redistribution and use in source and binary forms are permitted provided - * that: (1) source distributions retain this entire copyright notice and - * comment, and (2) distributions including binaries display the following - * acknowledgement: ``This product includes software developed by the - * University of California, Berkeley and its contributors'' in the - * documentation or other materials provided with the distribution and in - * all advertising materials mentioning features or use of this software. - * Neither the name of the University nor the names of its contributors may - * be used to endorse or promote products derived from this software without - * specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED - * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. */ #if defined(LIBC_SCCS) && !defined(lint) -static char sccsid[] = "@(#)fts.c 5.10 (Berkeley) 6/9/90"; +static char sccsid[] = "@(#)fts.c 5.19 (Berkeley) 5/9/91"; #endif /* LIBC_SCCS and not lint */ +#include #include #include #include #include #include -#include -#include +#include "fts.h" #include +#include +#include -FTSENT *fts_alloc(), *fts_build(), *fts_cycle(), *fts_sort(), *fts_root(); -short fts_stat(); - -/* - * Special case a root of "/" so that slashes aren't appended causing - * paths to be written as "//foo". - */ -#define NAPPEND(p) \ - (p->fts_level == ROOTLEVEL && p->fts_pathlen == 1 && \ - p->fts_path[0] == '/' ? 0 : p->fts_pathlen) +static FTSENT *fts_alloc(), *fts_build(), *fts_sort(); +static void fts_load(), fts_lfree(); +static u_short fts_stat(); +static char *fts_path(); -#define CHDIR(sp, path) (!(sp->fts_options & FTS_NOCHDIR) && chdir(path)) -#define FCHDIR(sp, fd) (!(sp->fts_options & FTS_NOCHDIR) && fchdir(fd)) +#define ISSET(opt) (sp->fts_options & opt) +#define SET(opt) (sp->fts_options |= opt) -#define ROOTLEVEL 0 -#define ROOTPARENTLEVEL -1 +#define CHDIR(sp, path) (!ISSET(FTS_NOCHDIR) && chdir(path)) +#define FCHDIR(sp, fd) (!ISSET(FTS_NOCHDIR) && fchdir(fd)) /* fts_build flags */ -#define BCHILD 1 /* from ftschildren */ -#define BREAD 2 /* from ftsread */ - -static FTS *stream; /* current stream pointer */ +#define BCHILD 1 /* from fts_children */ +#define BREAD 2 /* from fts_read */ FTS * -ftsopen(argv, options, compar) - char *argv[]; +fts_open(argv, options, compar) + char * const *argv; register int options; int (*compar)(); { @@ -63,36 +71,38 @@ ftsopen(argv, options, compar) register FTSENT *p, *root; register int nitems, maxlen; FTSENT *parent, *tmp; - char *fts_path(); + int len; - /* allocate/initialize the stream */ - if (!(stream = sp = (FTS *)malloc((u_int)sizeof(FTS)))) + /* Allocate/initialize the stream */ + if (!(sp = (FTS *)malloc((u_int)sizeof(FTS)))) return(NULL); bzero(sp, sizeof(FTS)); sp->fts_compar = compar; - - /* - * logical walks turn on NOCHDIR; symbolic links are just too - * hard to deal with. - */ sp->fts_options = options; - if (options & FTS_LOGICAL) - sp->fts_options |= FTS_NOCHDIR; - /* allocate/initialize root's parent */ - if (!(parent = fts_alloc("", 0))) + /* Logical walks turn on NOCHDIR; symbolic links are too hard. */ + if (ISSET(FTS_LOGICAL)) + SET(FTS_NOCHDIR); + + /* Allocate/initialize root's parent. */ + if (!(parent = fts_alloc(sp, "", 0))) goto mem1; - parent->fts_level = ROOTPARENTLEVEL; + parent->fts_level = FTS_ROOTPARENTLEVEL; - /* allocate/initialize root(s) */ + /* Allocate/initialize root(s). */ maxlen = -1; for (root = NULL, nitems = 0; *argv; ++argv, ++nitems) { - if (!(p = fts_root(*argv))) + if (!(len = strlen(*argv))) { + errno = ENOENT; goto mem2; - if (maxlen < p->fts_namelen) - maxlen = p->fts_namelen; + } + if (maxlen < len) + maxlen = len; + p = fts_alloc(sp, *argv, len); + p->fts_level = FTS_ROOTLEVEL; + p->fts_parent = parent; /* - * if comparison routine supplied, traverse in sorted + * If comparison routine supplied, traverse in sorted * order; otherwise traverse in the order specified. */ if (compar) { @@ -100,7 +110,7 @@ ftsopen(argv, options, compar) root = p; p->fts_accpath = p->fts_name; if (!(options & FTS_NOSTAT)) - p->fts_info = fts_stat(p, 0); + p->fts_info = fts_stat(sp, p, 0); } else { p->fts_link = NULL; if (!root) @@ -110,69 +120,71 @@ ftsopen(argv, options, compar) tmp = p; } } - p->fts_level = ROOTLEVEL; - p->fts_parent = parent; } if (compar && nitems > 1) - root = fts_sort(root, nitems); + root = fts_sort(sp, root, nitems); /* - * allocate a dummy pointer and make ftsread think that we've just + * Allocate a dummy pointer and make fts_read think that we've just * finished the node before the root(s); set p->fts_info to FTS_NS * so that everything about the "current" node is ignored. */ - if (!(sp->fts_cur = fts_alloc("", 0))) + if (!(sp->fts_cur = fts_alloc(sp, "", 0))) goto mem2; sp->fts_cur->fts_link = root; sp->fts_cur->fts_info = FTS_NS; - /* start out with at least 1K+ of path space */ - if (!fts_path(MAX(maxlen, MAXPATHLEN))) + /* Start out with at least 1K+ of path space. */ + if (!fts_path(sp, MAX(maxlen, MAXPATHLEN))) goto mem3; /* - * if using chdir(2), grab a file descriptor pointing to dot to insure + * If using chdir(2), grab a file descriptor pointing to dot to insure * that we can get back here; this could be avoided for some paths, * but almost certainly not worth the effort. Slashes, symbolic links, * and ".." are all fairly nasty problems. Note, if we can't get the * descriptor we run anyway, just more slowly. */ - if (!(options & FTS_NOCHDIR) && - (sp->fts_sd = open(".", O_RDONLY, 0)) < 0) - sp->fts_options |= FTS_NOCHDIR; + if (!ISSET(FTS_NOCHDIR) && (sp->fts_rfd = open(".", O_RDONLY, 0)) < 0) + SET(FTS_NOCHDIR); return(sp); -mem3: (void)free((void *)sp->fts_cur); +mem3: free(sp->fts_cur); mem2: fts_lfree(root); - (void)free((void *)parent); -mem1: (void)free((void *)sp); + free(parent); +mem1: free(sp); return(NULL); } -static -fts_load(p) +static void +fts_load(sp, p) + FTS *sp; register FTSENT *p; { register int len; register char *cp; /* - * load the stream structure for the next traversal; set the - * accpath field specially so the chdir gets done to the right + * Load the stream structure for the next traversal. Since we don't + * actually enter the directory until after the preorder visit, set + * the fts_accpath field specially so the chdir gets done to the right * place and the user can access the first node. */ len = p->fts_pathlen = p->fts_namelen; - bcopy(p->fts_name, stream->fts_path, len + 1); + bcopy(p->fts_name, sp->fts_path, len + 1); if ((cp = rindex(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) { len = strlen(++cp); bcopy(cp, p->fts_name, len + 1); p->fts_namelen = len; } - p->fts_accpath = p->fts_path = stream->fts_path; + p->fts_accpath = p->fts_path = sp->fts_path; + + p->fts_info = fts_stat(sp, p, 0); + sp->rdev = p->fts_statb.st_dev; } -ftsclose(sp) +fts_close(sp) FTS *sp; { register FTSENT *freep, *p; @@ -180,89 +192,96 @@ ftsclose(sp) if (sp->fts_cur) { /* - * this still works if we haven't read anything -- the dummy + * This still works if we haven't read anything -- the dummy * structure points to the root list, so we step through to * the end of the root list which has a valid parent pointer. */ - for (p = sp->fts_cur; p->fts_level > ROOTPARENTLEVEL;) { + for (p = sp->fts_cur; p->fts_level > FTS_ROOTPARENTLEVEL;) { freep = p; p = p->fts_link ? p->fts_link : p->fts_parent; - (void)free((void *)freep); + free(freep); } - (void)free((void *)p); + free(p); } - /* free up child linked list, sort array, path buffer */ + /* Free up child linked list, sort array, path buffer. */ if (sp->fts_child) fts_lfree(sp->fts_child); if (sp->fts_array) - (void)free((void *)sp->fts_array); - (void)free((char *)sp->fts_path); + free(sp->fts_array); + free(sp->fts_path); - /* - * return to original directory, save errno if necessary; - * free up the directory buffer - */ - if (!(sp->fts_options & FTS_NOCHDIR)) { - saved_errno = fchdir(sp->fts_sd) ? errno : 0; - (void)close(sp->fts_sd); + /* Return to original directory, save errno if necessary. */ + if (!ISSET(FTS_NOCHDIR)) { + saved_errno = fchdir(sp->fts_rfd) ? errno : 0; + (void)close(sp->fts_rfd); } - /* free up the stream pointer */ - (void)free((void *)sp); + /* Free up the stream pointer. */ + free(sp); - /* set errno and return */ - if (!(sp->fts_options & FTS_NOCHDIR) && saved_errno) { + /* Set errno and return. */ + if (!ISSET(FTS_NOCHDIR) && saved_errno) { errno = saved_errno; return(-1); } return(0); } +/* + * Special case a root of "/" so that slashes aren't appended causing + * paths to be written as "//foo". + */ +#define NAPPEND(p) \ + (p->fts_level == FTS_ROOTLEVEL && p->fts_pathlen == 1 && \ + p->fts_path[0] == '/' ? 0 : p->fts_pathlen) + FTSENT * -ftsread(sp) +fts_read(sp) register FTS *sp; { register FTSENT *p, *tmp; register int instr; - register char *cp; - static int cd; + register char *t; - /* if finished or unrecoverable error, return NULL */ - if (!sp->fts_cur || sp->fts_options & FTS__STOP) + /* If finished or unrecoverable error, return NULL. */ + if (!sp->fts_cur || ISSET(FTS_STOP)) return(NULL); - /* set global stream pointer, and current node pointer */ - stream = sp; + /* Set current node pointer. */ p = sp->fts_cur; - /* save and zero out user instructions */ + /* Save and zero out user instructions. */ instr = p->fts_instr; - p->fts_instr = 0; + p->fts_instr = FTS_NOINSTR; - /* if used link pointer for cycle detection, restore it */ + /* If used fts_link pointer for cycle detection, restore it. */ if (sp->fts_savelink) { p->fts_link = sp->fts_savelink; sp->fts_savelink = NULL; } - /* any type of file may be re-visited; re-stat and return */ + /* Any type of file may be re-visited; re-stat and re-turn. */ if (instr == FTS_AGAIN) { - p->fts_info = fts_stat(p, 0); + p->fts_info = fts_stat(sp, p, 0); return(p); } - /* following a symbolic link */ - if (p->fts_info == FTS_SL && instr == FTS_FOLLOW) { - p->fts_info = fts_stat(p, 1); + /* + * Following a symlink -- SLNONE test allows application to see + * SLNONE and recover. + */ + if (instr == FTS_FOLLOW && + (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) { + p->fts_info = fts_stat(sp, p, 1); return(p); } - /* directory in pre-order */ + /* Directory in pre-order. */ if (p->fts_info == FTS_D) { - /* if skipped or crossed mount point, do post-order visit */ - if (instr == FTS_SKIP || sp->fts_options & FTS_XDEV && - p->fts_statb.st_dev != sp->sdev) { + /* If skipped or crossed mount point, do post-order visit. */ + if (instr == FTS_SKIP || + ISSET(FTS_XDEV) && p->fts_statb.st_dev != sp->rdev) { if (sp->fts_child) { fts_lfree(sp->fts_child); sp->fts_child = NULL; @@ -271,91 +290,105 @@ ftsread(sp) return(p); } - /* read the directory if necessary, and return first entry */ - if (sp->fts_child) + /* + * Cd to the subdirectory, reading it if haven't already. If + * the read fails for any reason, or the directory is empty, + * the fts_info field of the current node is set by fts_build. + * If have already read and now fail to chdir, whack the list + * to make the names come out right, and set the parent state + * so the application will eventually get an error condition. + * If haven't read and fail to chdir, check to see if we're + * at the root node -- if so, we have to get back or the root + * node may be inaccessible. + */ + if (sp->fts_child) { if (CHDIR(sp, p->fts_accpath)) { - fts_lfree(sp->fts_child); - p->fts_info = FTS_DNX; - } else { - p = sp->fts_child; - cp = sp->fts_path + NAPPEND(p->fts_parent); - *cp++ = '/'; - bcopy(p->fts_name, cp, p->fts_namelen + 1); + p->fts_parent->fts_cderr = errno; + for (p = sp->fts_child; p; p = p->fts_link) + p->fts_accpath = + p->fts_parent->fts_accpath; } - else { - if (!(sp->fts_child = fts_build(sp, BREAD))) - return(p); - p = sp->fts_child; + } else if (!(sp->fts_child = fts_build(sp, BREAD))) { + if ISSET(FTS_STOP) + return(NULL); + if (p->fts_level == FTS_ROOTLEVEL && + FCHDIR(sp, sp->fts_rfd)) { + SET(FTS_STOP); + return(NULL); + } + return(p); } + p = sp->fts_child; sp->fts_child = NULL; - return(sp->fts_cur = p); + goto name; } - /* move to next node on this level */ + /* Move to next node on this level. */ next: tmp = p; if (p = p->fts_link) { - /* - * if root level node, set up paths and return. If not the - * first time, and it's not an absolute pathname, get back - * to starting directory. - */ - if (p->fts_level == ROOTLEVEL) { - fts_load(p); - (void)free((void *)tmp); - if (cd && - p->fts_path[0] != '/' && FCHDIR(sp, sp->fts_sd)) { - /* should never happen... */ - p->fts_path = "starting directory"; - p->fts_info = FTS_ERR; - sp->fts_options |= FTS__STOP; - return(sp->fts_cur = p); - } - cd = 1; - p->fts_info = fts_stat(p, 0); - sp->sdev = p->fts_statb.st_dev; - } else { - (void)free((void *)tmp); - - /* user may have called ftsset on node */ - if (p->fts_instr == FTS_SKIP) - goto next; - if (p->fts_instr == FTS_FOLLOW) { - p->fts_info = fts_stat(p, 1); - p->fts_instr = 0; - } + free(tmp); - /* fill in the paths */ - cp = sp->fts_path + NAPPEND(p->fts_parent); - *cp++ = '/'; - bcopy(p->fts_name, cp, p->fts_namelen + 1); + /* If reached the top, load the paths for the next root. */ + if (p->fts_level == FTS_ROOTLEVEL) { + fts_load(sp, p); + return(sp->fts_cur = p); + } - /* check for directory cycles */ - if (p->fts_info == FTS_D && (tmp = fts_cycle(p))) { - sp->fts_savelink = p->fts_link; - p->fts_link = tmp; - p->fts_info = FTS_DC; - } + /* User may have called fts_set on the node. */ + if (p->fts_instr == FTS_SKIP) + goto next; + if (p->fts_instr == FTS_FOLLOW) { + p->fts_info = fts_stat(sp, p, 1); + p->fts_instr = FTS_NOINSTR; } + +name: t = sp->fts_path + NAPPEND(p->fts_parent); + *t++ = '/'; + bcopy(p->fts_name, t, p->fts_namelen + 1); return(sp->fts_cur = p); } - /* move to parent */ + /* Move up to the parent node. */ p = tmp->fts_parent; - (void)free((void *)tmp); + free(tmp); - if (p->fts_level == ROOTPARENTLEVEL) { + if (p->fts_level == FTS_ROOTPARENTLEVEL) { /* - * done; free everything up and set errno to 0 so the user + * Done; free everything up and set errno to 0 so the user * can distinguish between error and EOF. */ - (void)free((void *)p); + free(p); errno = 0; return(sp->fts_cur = NULL); } sp->fts_path[p->fts_pathlen] = '\0'; - if (CHDIR(sp, "..")) { - sp->fts_options |= FTS__STOP; + + /* + * Cd back up to the parent directory. If at a root node, have to cd + * back to the original place, otherwise may not be able to access the + * original node on post-order. + */ + if (p->fts_level == FTS_ROOTLEVEL) { + if (FCHDIR(sp, sp->fts_rfd)) { + SET(FTS_STOP); + return(NULL); + } + } + else if (CHDIR(sp, "..")) { + SET(FTS_STOP); + return(NULL); + } + + /* + * If had a chdir error when trying to get into the directory, set the + * info field to reflect this, and restore errno. The error indicator + * has to be reset to 0 so that if the user does an FTS_AGAIN, it all + * works. + */ + if (p->fts_cderr) { + errno = p->fts_cderr; + p->fts_cderr = 0; p->fts_info = FTS_ERR; } else p->fts_info = FTS_DP; @@ -363,13 +396,13 @@ next: tmp = p; } /* - * ftsset takes the stream as an argument although it's not used in this + * Fts_set takes the stream as an argument although it's not used in this * implementation; it would be necessary if anyone wanted to add global - * semantics to fts using ftsset. A possible error return is allowed for - * similar reasons. + * semantics to fts using fts_set. An error return is allowed for similar + * reasons. */ /* ARGSUSED */ -ftsset(sp, p, instr) +fts_set(sp, p, instr) FTS *sp; FTSENT *p; int instr; @@ -379,31 +412,38 @@ ftsset(sp, p, instr) } FTSENT * -ftschildren(sp) +fts_children(sp) register FTS *sp; { register FTSENT *p; int fd; + /* Set current node pointer. */ + p = sp->fts_cur; + /* - * set errno to 0 so that user can tell the difference between an - * error and a directory without entries. + * Set errno to 0 so that user can tell the difference between an + * error and a directory without entries. If not a directory being + * visited in *pre-order*, or we've already had fatal errors, return + * immediately. */ errno = 0; - p = sp->fts_cur; - if (p->fts_info != FTS_D || sp->fts_options & FTS__STOP) + if (ISSET(FTS_STOP) || p->fts_info != FTS_D && p->fts_info != FTS_DNR) return(NULL); + + /* Free up any previous child list. */ if (sp->fts_child) fts_lfree(sp->fts_child); /* - * if using chdir on a relative path and called BEFORE ftsread on the - * root of a traversal, we can lose because we need to chdir into the - * subdirectory, and we don't know where the current directory is to - * get back so that the upcoming chdir by ftsread will work. + * If using chdir on a relative path and called BEFORE fts_read does + * its chdir to the root of a traversal, we can lose -- we need to + * chdir into the subdirectory, and we don't know where the current + * directory is, so we can't get back so that the upcoming chdir by + * fts_read will work. */ - if (p->fts_level != ROOTLEVEL || p->fts_accpath[0] == '/' || - sp->fts_options & FTS_NOCHDIR) + if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' || + ISSET(FTS_NOCHDIR)) return(sp->fts_child = fts_build(sp, BCHILD)); if ((fd = open(".", O_RDONLY, 0)) < 0) @@ -415,9 +455,21 @@ ftschildren(sp) return(sp->fts_child); } +/* + * This is the tricky part -- do not casually change *anything* in here. The + * idea is to build the linked list of entries that are used by fts_children + * and fts_read. There are lots of special cases. + * + * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is + * set and it's a physical walk (so that symbolic links can't be directories), + * we assume that the number of subdirectories in a node is equal to the number + * of links to the parent. This allows stat calls to be skipped in any leaf + * directories and for any nodes after the directories in the parent node have + * been found. This empirically cuts the stat calls by about 2/3. + */ #define ISDOT(a) (a[0] == '.' && (!a[1] || a[1] == '.' && !a[2])) -FTSENT * +static FTSENT * fts_build(sp, type) register FTS *sp; int type; @@ -425,101 +477,126 @@ fts_build(sp, type) register struct dirent *dp; register FTSENT *p, *head; register int nitems; + FTSENT *cur; DIR *dirp; - int descend, len, level, maxlen, nlinks, saved_errno; + int cderr, descend, len, level, maxlen, nlinks, saved_errno; char *cp; - p = sp->fts_cur; - if (!(dirp = opendir(p->fts_accpath))) { - if (type == BREAD) { - errno = 0; - p->fts_info = FTS_DNR; - } + /* Set current node pointer. */ + cur = sp->fts_cur; + + /* + * Open the directory for reading. If this fails, we're done. + * If being called from fts_read, set the fts_info field. + */ + if (!(dirp = opendir(cur->fts_accpath))) { + if (type == BREAD) + cur->fts_info = FTS_DNR; return(NULL); } /* - * the real slowdown in walking the tree is the stat calls. If - * FTS_NOSTAT is set and it's a physical walk (so that symbolic - * links can't be directories), fts assumes that the number of - * subdirectories in a node is equal to the number of links to - * the parent. This allows stat calls to be skipped in any leaf - * directories and for any nodes after the directories in the - * parent node have been found. This empirically cuts the stat - * calls by about 2/3. + * Nlinks is the number of possible entries of type directory in the + * directory if we're cheating on stat calls, 0 if we're not doing + * any stat calls at all, -1 if we're doing stats on everything. */ nlinks = - sp->fts_options & FTS_NOSTAT && sp->fts_options & FTS_PHYSICAL ? - p->fts_statb.st_nlink - (sp->fts_options & FTS_SEEDOT ? 0 : 2) : -1; + ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL) ? + cur->fts_statb.st_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2) : -1; - /* if told to descend or found links and not told not to descend. */ - if (nlinks || type == BREAD) { + /* + * If we're going to need to stat anything or we want to descend + * and stay in the directory, chdir. If this fails we keep going. + * We won't be able to stat anything, but we can still return the + * names themselves. Note, that since fts_read won't be able to + * chdir into the directory, it will have to return different path + * names than before, i.e. "a/b" instead of "b". Since the node + * has already been visited in pre-order, have to wait until the + * post-order visit to return the error. This is all fairly nasty. + * If a program needed sorted entries or stat information, they had + * better be checking FTS_NS on the returned nodes. + */ + if (nlinks || type == BREAD) if (FCHDIR(sp, dirfd(dirp))) { - if (type == BREAD) { - errno = 0; - p->fts_info = FTS_DNX; - } - (void)closedir(dirp); - return(NULL); + if (type == BREAD) + cur->fts_cderr = errno; + descend = nlinks = 0; + cderr = 1; + } else { + descend = 1; + cderr = 0; } - descend = 1; - } else + else descend = 0; - /* get max file name length that can be stored in current path */ - maxlen = sp->fts_pathlen - p->fts_pathlen - 1; - - cp = sp->fts_path + (len = NAPPEND(p)); - *cp++ = '/'; + /* + * Figure out the max file name length that can be stored in the + * current path -- the inner loop allocates more path as necessary. + * We really wouldn't have to do the maxlen calculations here, we + * could do them in fts_read before returning the path, but it's a + * lot easier here since the length is part of the dirent structure. + * + * If not changing directories set a pointer so that we can just + * append each new name into the path. + */ + maxlen = sp->fts_pathlen - cur->fts_pathlen - 1; + len = NAPPEND(cur); + if (ISSET(FTS_NOCHDIR)) { + cp = sp->fts_path + len; + *cp++ = '/'; + } - level = p->fts_level + 1; + level = cur->fts_level + 1; - /* read the directory, attching each new entry to the `link' pointer */ + /* Read the directory, attaching each entry to the `link' pointer. */ for (head = NULL, nitems = 0; dp = readdir(dirp);) { - if (ISDOT(dp->d_name) && !(sp->fts_options & FTS_SEEDOT)) + if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name)) continue; - if (!(p = fts_alloc(dp->d_name, dp->d_namlen))) { - saved_errno = errno; + if (!(p = fts_alloc(sp, dp->d_name, (int)dp->d_namlen))) goto mem1; - } if (dp->d_namlen > maxlen) { - if (!fts_path((int)dp->d_namlen)) { - /* quit: this stream no longer has a path */ - sp->fts_options |= FTS__STOP; - saved_errno = errno; - (void)free((void *)p); -mem1: fts_lfree(head); - if (type == BREAD) - p->fts_info = FTS_ERR; - if (descend && CHDIR(sp, "..")) { - saved_errno = errno; - sp->fts_options |= FTS__STOP; - } - errno = saved_errno; + if (!fts_path(sp, (int)dp->d_namlen)) { + /* + * No more memory for path or structures. Save + * errno, free up the current structure and the + * structures already allocated. + */ +mem1: saved_errno = errno; + if (p) + free(p); + fts_lfree(head); (void)closedir(dirp); + errno = saved_errno; + cur->fts_info = FTS_ERR; + SET(FTS_STOP); return(NULL); } maxlen = sp->fts_pathlen - sp->fts_cur->fts_pathlen - 1; } p->fts_pathlen = len + dp->d_namlen + 1; - p->fts_accpath = - sp->fts_options & FTS_NOCHDIR ? p->fts_path : p->fts_name; - p->fts_parent = sp->fts_cur; p->fts_level = level; if (nlinks) { - /* make sure fts_stat has a filename to stat */ - if (sp->fts_options & FTS_NOCHDIR) + /* Build a file name for fts_stat to stat. */ + if (ISSET(FTS_NOCHDIR)) { + p->fts_accpath = p->fts_path; bcopy(p->fts_name, cp, p->fts_namelen + 1); - p->fts_info = fts_stat(p, 0); - if (nlinks > 0 && (p->fts_info == FTS_D || - p->fts_info == FTS_DNR || p->fts_info == FTS_DNX)) + } else + p->fts_accpath = p->fts_name; + p->fts_info = fts_stat(sp, p, 0); + if (nlinks > 0 && p->fts_info == FTS_D) --nlinks; - } else - p->fts_info = FTS_NS; + } else if (cderr) { + p->fts_info = ISSET(FTS_NOSTAT) ? FTS_NSOK : FTS_NS; + p->fts_accpath = cur->fts_accpath; + } else { + p->fts_accpath = + ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name; + p->fts_info = FTS_NSOK; + } p->fts_link = head; head = p; @@ -527,188 +604,184 @@ mem1: fts_lfree(head); } (void)closedir(dirp); - /* reset the path */ - if (cp - 1 > sp->fts_path) - --cp; - *cp = '\0'; + /* + * If not changing directories, reset the path back to original + * state. + */ + if (ISSET(FTS_NOCHDIR)) { + if (cp - 1 > sp->fts_path) + --cp; + *cp = '\0'; + } /* - * if descended: if were called from ftsread and didn't find anything, - * or were called from ftschildren, get back. + * If descended after called from fts_children or called from + * fts_read and didn't find anything, get back. If can't get + * back, we're done. */ if (descend && (!nitems || type == BCHILD) && CHDIR(sp, "..")) { - sp->fts_options |= FTS__STOP; - p->fts_info = FTS_ERR; + cur->fts_info = FTS_ERR; + SET(FTS_STOP); return(NULL); } + /* If we didn't find anything, just do the post-order visit */ if (!nitems) { if (type == BREAD) - p->fts_info = FTS_DP; + cur->fts_info = FTS_DP; return(NULL); } + /* Sort the entries. */ if (sp->fts_compar && nitems > 1) - head = fts_sort(head, nitems); - - if (type == BREAD) { - *cp = '/'; - bcopy(head->fts_name, cp + 1, head->fts_namelen + 1); - } + head = fts_sort(sp, head, nitems); return(head); } -static short -fts_stat(p, symflag) +static u_short +fts_stat(sp, p, follow) + FTS *sp; register FTSENT *p; - int symflag; + int follow; { + int saved_errno; + /* - * detection of symbolic links w/o targets. If FTS_FOLLOW is set, - * the symlink structure is overwritten with the stat structure of - * the target. + * If doing a logical walk, or application requested FTS_FOLLOW, do + * a stat(2). If that fails, check for a non-existent symlink. If + * fail, return the errno from the stat call. */ - if (stream->fts_options & FTS_LOGICAL || symflag) { - if (stat(p->fts_accpath, &p->fts_statb)) - return(symflag || !lstat(p->fts_accpath, - &p->fts_statb) ? FTS_SLNONE : FTS_ERR); - } else if (lstat(p->fts_accpath, &p->fts_statb)) - return(FTS_ERR); - - switch(p->fts_statb.st_mode&S_IFMT) { - case S_IFDIR: - return(FTS_D); - case S_IFLNK: - return(FTS_SL); - case S_IFREG: - return(FTS_F); + if (ISSET(FTS_LOGICAL) || follow) { + if (stat(p->fts_accpath, &p->fts_statb)) { + saved_errno = errno; + if (!lstat(p->fts_accpath, &p->fts_statb)) { + errno = 0; + return(FTS_SLNONE); + } + errno = saved_errno; + bzero(&p->fts_statb, sizeof(struct stat)); + return(FTS_NS); + } + } else if (lstat(p->fts_accpath, &p->fts_statb)) { + bzero(&p->fts_statb, sizeof(struct stat)); + return(FTS_NS); } - return(FTS_DEFAULT); -} - -static FTSENT * -fts_cycle(p) - register FTSENT *p; -{ - register dev_t dev; - register ino_t ino; /* - * cycle detection is brute force; if the tree gets deep enough or - * the number of symbolic links to directories is really high - * something faster might be worthwhile. + * Cycle detection is done as soon as we find a directory. Detection + * is by brute force; if the tree gets deep enough or the number of + * symbolic links to directories high enough something faster might + * be worthwhile. */ - dev = p->fts_statb.st_dev; - ino = p->fts_statb.st_ino; - for (p = p->fts_parent; p->fts_level > ROOTLEVEL; p = p->fts_parent) - if (ino == p->fts_statb.st_ino && dev == p->fts_statb.st_dev) - return(p); - return(NULL); + if (S_ISDIR(p->fts_statb.st_mode)) { + register FTSENT *t; + register dev_t dev; + register ino_t ino; + + dev = p->fts_statb.st_dev; + ino = p->fts_statb.st_ino; + for (t = p->fts_parent; t->fts_level > FTS_ROOTLEVEL; + t = t->fts_parent) + if (ino == t->fts_statb.st_ino && + dev == t->fts_statb.st_dev) { + sp->fts_savelink = p->fts_link; + p->fts_link = t; + return(FTS_DC); + } + return(FTS_D); + } + if (S_ISLNK(p->fts_statb.st_mode)) + return(FTS_SL); + if (S_ISREG(p->fts_statb.st_mode)) + return(FTS_F); + return(FTS_DEFAULT); } #define R(type, nelem, ptr) \ (type *)realloc((void *)ptr, (u_int)((nelem) * sizeof(type))) static FTSENT * -fts_sort(head, nitems) +fts_sort(sp, head, nitems) + FTS *sp; FTSENT *head; register int nitems; { register FTSENT **ap, *p; /* - * construct an array of pointers to the structures and call qsort(3). + * Construct an array of pointers to the structures and call qsort(3). * Reassemble the array in the order returned by qsort. If unable to * sort for memory reasons, return the directory entries in their * current order. Allocate enough space for the current needs plus * 40 so we don't realloc one entry at a time. */ - if (nitems > stream->fts_nitems) { - stream->fts_nitems = nitems + 40; - if (!(stream->fts_array = - R(FTSENT *, stream->fts_nitems, stream->fts_array))) { - stream->fts_nitems = 0; + if (nitems > sp->fts_nitems) { + sp->fts_nitems = nitems + 40; + if (!(sp->fts_array = + R(FTSENT *, sp->fts_nitems, sp->fts_array))) { + sp->fts_nitems = 0; return(head); } } - for (ap = stream->fts_array, p = head; p; p = p->fts_link) + for (ap = sp->fts_array, p = head; p; p = p->fts_link) *ap++ = p; - qsort((void *)stream->fts_array, nitems, sizeof(FTSENT *), - stream->fts_compar); - for (head = *(ap = stream->fts_array); --nitems; ++ap) + qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *), sp->fts_compar); + for (head = *(ap = sp->fts_array); --nitems; ++ap) ap[0]->fts_link = ap[1]; ap[0]->fts_link = NULL; return(head); } static FTSENT * -fts_alloc(name, len) +fts_alloc(sp, name, len) + FTS *sp; char *name; register int len; { register FTSENT *p; /* - * variable sized structures; the name is the last element so - * allocate enough extra space after the structure to hold it. + * Variable sized structures; the name is the last element so + * we allocate enough extra space after the structure to store + * it. */ if (!(p = (FTSENT *)malloc((size_t)(sizeof(FTSENT) + len)))) return(NULL); bcopy(name, p->fts_name, len + 1); p->fts_namelen = len; - p->fts_path = stream->fts_path; - p->fts_instr = 0; - p->fts_local.number = 0; - p->fts_local.pointer = NULL; + p->fts_path = sp->fts_path; + p->fts_instr = FTS_NOINSTR; + p->fts_cderr = 0; + p->fts_number = 0; + p->fts_pointer = NULL; return(p); } -static +static void fts_lfree(head) register FTSENT *head; { register FTSENT *p; + /* Free a linked list of structures. */ while (p = head) { head = head->fts_link; - (void)free((void *)p); + free(p); } } /* - * allow essentially unlimited paths; certain programs (find, remove, ls) - * need to work on any tree. Most systems will allow creation of paths - * much longer than MAXPATHLEN, even though the kernel won't resolve them. - * Add an extra 128 bytes to the requested size so that we don't realloc - * the path 2 bytes at a time. + * Allow essentially unlimited paths; certain programs (find, rm, ls) need to + * work on any tree. Most systems will allow creation of paths much longer + * than MAXPATHLEN, even though the kernel won't resolve them. Add an extra + * 128 bytes to the requested size so that we don't realloc the path 2 bytes + * at a time. */ static char * -fts_path(size) +fts_path(sp, size) + FTS *sp; int size; { - stream->fts_pathlen += size + 128; - return(stream->fts_path = - R(char, stream->fts_pathlen, stream->fts_path)); -} - -static FTSENT * -fts_root(name) - register char *name; -{ - register char *cp; - - /* - * rip trailing slashes; it's somewhat unclear in POSIX 1003.1 what - * /a/b/ really is, they don't talk about what a null path component - * resolves to. This hopefully does what the user intended. Don't - * allow null pathnames. - */ - for (cp = name; *cp; ++cp); - if (cp == name) { - errno = ENOENT; - return(NULL); - } - while (--cp > name && *cp == '/'); - *++cp = '\0'; - return(fts_alloc(name, cp - name)); + sp->fts_pathlen += size + 128; + return(sp->fts_path = R(char, sp->fts_pathlen, sp->fts_path)); }