Update.
[kopensolaris-gnu/glibc.git] / io / fts.c
index 044779d..0172af7 100644 (file)
--- a/io/fts.c
+++ b/io/fts.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 1990, 1993
+ * Copyright (c) 1990, 1993, 1994
  *     The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * 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.
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)fts.c      8.2 (Berkeley) 1/2/94";
+static char sccsid[] = "@(#)fts.c      8.6 (Berkeley) 8/14/94";
 #endif /* LIBC_SCCS and not lint */
 
 #include <sys/param.h>
-#include <sys/stat.h>
+#include <include/sys/stat.h>
 #include <fcntl.h>
 #include <dirent.h>
 #include <errno.h>
@@ -57,23 +53,30 @@ static char sccsid[] = "@(#)fts.c   8.2 (Berkeley) 1/2/94";
 #endif
 
 
-static FTSENT  *fts_alloc __P((FTS *, char *, int));
-static FTSENT  *fts_build __P((FTS *, int));
-static void     fts_lfree __P((FTSENT *));
+static FTSENT  *fts_alloc __P((FTS *, const char *, int)) internal_function;
+static FTSENT  *fts_build __P((FTS *, int)) internal_function;
+static void     fts_lfree __P((FTSENT *)) internal_function;
 static void     fts_load __P((FTS *, FTSENT *));
-static size_t   fts_maxarglen __P((char * const *));
-static void     fts_padjust __P((FTS *, void *));
-static int      fts_palloc __P((FTS *, size_t));
-static FTSENT  *fts_sort __P((FTS *, FTSENT *, int));
-static u_short  fts_stat __P((FTS *, FTSENT *, int));
+static size_t   fts_maxarglen __P((char * const *)) internal_function;
+static void     fts_padjust __P((FTS *, void *)) internal_function;
+static int      fts_palloc __P((FTS *, size_t)) internal_function;
+static FTSENT  *fts_sort __P((FTS *, FTSENT *, int)) internal_function;
+static u_short  fts_stat __P((FTS *, struct dirent *, FTSENT *, int))
+     internal_function;
+
+#ifndef MAX
+#define MAX(a, b)      ({ __typeof__ (a) _a = (a); \
+                          __typeof__ (b) _b = (b); \
+                          _a > _b ? _a : _b; })
+#endif
 
-#define        ISDOT(a)        (a[0] == '.' && (!a[1] || a[1] == '.' && !a[2]))
+#define        ISDOT(a)        (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
 
 #define        ISSET(opt)      (sp->fts_options & opt)
 #define        SET(opt)        (sp->fts_options |= opt)
 
-#define        CHDIR(sp, path) (!ISSET(FTS_NOCHDIR) && chdir(path))
-#define        FCHDIR(sp, fd)  (!ISSET(FTS_NOCHDIR) && fchdir(fd))
+#define        CHDIR(sp, path) (!ISSET(FTS_NOCHDIR) && __chdir(path))
+#define        FCHDIR(sp, fd)  (!ISSET(FTS_NOCHDIR) && __fchdir(fd))
 
 /* fts_build flags */
 #define        BCHILD          1               /* fts_children */
@@ -84,7 +87,7 @@ FTS *
 fts_open(argv, options, compar)
        char * const *argv;
        register int options;
-       int (*compar)();
+       int (*compar) __P((const FTSENT **, const FTSENT **));
 {
        register FTS *sp;
        register FTSENT *p, *root;
@@ -94,15 +97,15 @@ fts_open(argv, options, compar)
 
        /* Options check. */
        if (options & ~FTS_OPTIONMASK) {
-               errno = EINVAL;
+               __set_errno (EINVAL);
                return (NULL);
        }
 
        /* Allocate/initialize the stream */
        if ((sp = malloc((u_int)sizeof(FTS))) == NULL)
                return (NULL);
-       bzero(sp, sizeof(FTS));
-       sp->fts_compar = compar;
+       __bzero(sp, sizeof(FTS));
+       sp->fts_compar = (int (*) __P((const void *, const void *))) compar;
        sp->fts_options = options;
 
        /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
@@ -128,7 +131,7 @@ fts_open(argv, options, compar)
        for (root = NULL, nitems = 0; *argv; ++argv, ++nitems) {
                /* Don't allow zero-length paths. */
                if ((len = strlen(*argv)) == 0) {
-                       errno = ENOENT;
+                       __set_errno (ENOENT);
                        goto mem3;
                }
 
@@ -136,7 +139,7 @@ fts_open(argv, options, compar)
                p->fts_level = FTS_ROOTLEVEL;
                p->fts_parent = parent;
                p->fts_accpath = p->fts_name;
-               p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW));
+               p->fts_info = fts_stat(sp, NULL, p, ISSET(FTS_COMFOLLOW));
 
                /* Command-line "." and ".." are real directories. */
                if (p->fts_info == FTS_DOT)
@@ -179,7 +182,8 @@ fts_open(argv, options, compar)
         * and ".." are all fairly nasty problems.  Note, if we can't get the
         * descriptor we run anyway, just more slowly.
         */
-       if (!ISSET(FTS_NOCHDIR) && (sp->fts_rfd = open(".", O_RDONLY, 0)) < 0)
+       if (!ISSET(FTS_NOCHDIR)
+           && (sp->fts_rfd = __open(".", O_RDONLY, 0)) < 0)
                SET(FTS_NOCHDIR);
 
        return (sp);
@@ -223,6 +227,7 @@ fts_close(sp)
 {
        register FTSENT *freep, *p;
        int saved_errno;
+       int retval = 0;
 
        /*
         * This still works if we haven't read anything -- the dummy structure
@@ -247,19 +252,20 @@ fts_close(sp)
 
        /* 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);
+               saved_errno = __fchdir(sp->fts_rfd) ? errno : 0;
+               (void)__close(sp->fts_rfd);
        }
 
-       /* Free up the stream pointer. */
-       free(sp);
-
        /* Set errno and return. */
        if (!ISSET(FTS_NOCHDIR) && saved_errno) {
-               errno = saved_errno;
-               return (-1);
+               __set_errno (saved_errno);
+               retval = -1;
        }
-       return (0);
+
+       /* Free up the stream pointer. */
+       free (sp);
+
+       return retval;
 }
 
 /*
@@ -292,7 +298,7 @@ fts_read(sp)
 
        /* Any type of file may be re-visited; re-stat and re-turn. */
        if (instr == FTS_AGAIN) {
-               p->fts_info = fts_stat(sp, p, 0);
+               p->fts_info = fts_stat(sp, NULL, p, 0);
                return (p);
        }
 
@@ -304,13 +310,14 @@ fts_read(sp)
         */
        if (instr == FTS_FOLLOW &&
            (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
-               p->fts_info = fts_stat(sp, p, 1);
-               if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR))
-                       if ((p->fts_symfd = open(".", O_RDONLY, 0)) < 0) {
+               p->fts_info = fts_stat(sp, NULL, p, 1);
+               if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
+                       if ((p->fts_symfd = __open(".", O_RDONLY, 0)) < 0) {
                                p->fts_errno = errno;
                                p->fts_info = FTS_ERR;
                        } else
                                p->fts_flags |= FTS_SYMFOLLOW;
+               }
                return (p);
        }
 
@@ -318,16 +325,16 @@ fts_read(sp)
        if (p->fts_info == FTS_D) {
                /* If skipped or crossed mount point, do post-order visit. */
                if (instr == FTS_SKIP ||
-                   ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev) {
+                   (ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
                        if (p->fts_flags & FTS_SYMFOLLOW)
-                               (void)close(p->fts_symfd);
+                               (void)__close(p->fts_symfd);
                        if (sp->fts_child) {
                                fts_lfree(sp->fts_child);
                                sp->fts_child = NULL;
                        }
                        p->fts_info = FTS_DP;
                        return (p);
-               } 
+               }
 
                /* Rebuild if only read the names and now traversing. */
                if (sp->fts_child && sp->fts_options & FTS_NAMEONLY) {
@@ -368,7 +375,7 @@ fts_read(sp)
 
        /* Move to the next node on this level. */
 next:  tmp = p;
-       if (p = p->fts_link) {
+       if ((p = p->fts_link)) {
                free(tmp);
 
                /*
@@ -392,14 +399,15 @@ next:     tmp = p;
                if (p->fts_instr == FTS_SKIP)
                        goto next;
                if (p->fts_instr == FTS_FOLLOW) {
-                       p->fts_info = fts_stat(sp, p, 1);
-                       if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR))
+                       p->fts_info = fts_stat(sp, NULL, p, 1);
+                       if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
                                if ((p->fts_symfd =
-                                   open(".", O_RDONLY, 0)) < 0) {
+                                   __open(".", O_RDONLY, 0)) < 0) {
                                        p->fts_errno = errno;
                                        p->fts_info = FTS_ERR;
                                } else
                                        p->fts_flags |= FTS_SYMFOLLOW;
+                       }
                        p->fts_instr = FTS_NOINSTR;
                }
 
@@ -419,7 +427,7 @@ name:               t = sp->fts_path + NAPPEND(p->fts_parent);
                 * can distinguish between error and EOF.
                 */
                free(p);
-               errno = 0;
+               __set_errno (0);
                return (sp->fts_cur = NULL);
        }
 
@@ -439,12 +447,12 @@ name:             t = sp->fts_path + NAPPEND(p->fts_parent);
        } else if (p->fts_flags & FTS_SYMFOLLOW) {
                if (FCHDIR(sp, p->fts_symfd)) {
                        saved_errno = errno;
-                       (void)close(p->fts_symfd);
-                       errno = saved_errno;
+                       (void)__close(p->fts_symfd);
+                       __set_errno (saved_errno);
                        SET(FTS_STOP);
                        return (NULL);
                }
-               (void)close(p->fts_symfd);
+               (void)__close(p->fts_symfd);
        } else if (!(p->fts_flags & FTS_DONTCHDIR)) {
                if (CHDIR(sp, "..")) {
                        SET(FTS_STOP);
@@ -470,7 +478,7 @@ fts_set(sp, p, instr)
 {
        if (instr && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
            instr != FTS_NOINSTR && instr != FTS_SKIP) {
-               errno = EINVAL;
+               __set_errno (EINVAL);
                return (1);
        }
        p->fts_instr = instr;
@@ -486,7 +494,7 @@ fts_children(sp, instr)
        int fd;
 
        if (instr && instr != FTS_NAMEONLY) {
-               errno = EINVAL;
+               __set_errno (EINVAL);
                return (NULL);
        }
 
@@ -497,7 +505,7 @@ fts_children(sp, instr)
         * Errno set to 0 so user can distinguish empty directory from
         * an error.
         */
-       errno = 0;
+       __set_errno (0);
 
        /* Fatal errors stop here. */
        if (ISSET(FTS_STOP))
@@ -522,7 +530,7 @@ fts_children(sp, instr)
        if (instr == FTS_NAMEONLY) {
                sp->fts_options |= FTS_NAMEONLY;
                instr = BNAMES;
-       } else 
+       } else
                instr = BCHILD;
 
        /*
@@ -536,12 +544,12 @@ fts_children(sp, instr)
            ISSET(FTS_NOCHDIR))
                return (sp->fts_child = fts_build(sp, instr));
 
-       if ((fd = open(".", O_RDONLY, 0)) < 0)
+       if ((fd = __open(".", O_RDONLY, 0)) < 0)
                return (NULL);
        sp->fts_child = fts_build(sp, instr);
-       if (fchdir(fd))
+       if (__fchdir(fd))
                return (NULL);
-       (void)close(fd);
+       (void)__close(fd);
        return (sp->fts_child);
 }
 
@@ -560,11 +568,12 @@ fts_children(sp, instr)
  * been found, cutting the stat calls by about 2/3.
  */
 static FTSENT *
+internal_function
 fts_build(sp, type)
        register FTS *sp;
        int type;
 {
-       register struct dirent *dp;
+       struct dirent *dp;
        register FTSENT *p, *head;
        register int nitems;
        FTSENT *cur, *tail;
@@ -572,6 +581,9 @@ fts_build(sp, type)
        void *adjaddr;
        int cderrno, descend, len, level, maxlen, nlinks, saved_errno;
        char *cp;
+#ifdef DTF_HIDEW
+       int oflag;
+#endif
 
        /* Set current node pointer. */
        cur = sp->fts_cur;
@@ -580,7 +592,15 @@ fts_build(sp, type)
         * 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)) == NULL) {
+#ifdef DTF_HIDEW
+       if (ISSET (FTS_WHITEOUT))
+               oflag = DTF_NODUP|DTF_REWIND;
+       else
+               oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
+#else
+# define __opendir2(path, flag) __opendir(path)
+#endif
+       if ((dirp = __opendir2 (cur->fts_accpath, oflag)) == NULL) {
                if (type == BREAD) {
                        cur->fts_info = FTS_DNR;
                        cur->fts_errno = errno;
@@ -621,7 +641,7 @@ fts_build(sp, type)
         * checking FTS_NS on the returned nodes.
         */
        cderrno = 0;
-       if (nlinks || type == BREAD)
+       if (nlinks || type == BREAD) {
                if (FCHDIR(sp, dirfd(dirp))) {
                        if (nlinks && type == BREAD)
                                cur->fts_errno = errno;
@@ -630,7 +650,7 @@ fts_build(sp, type)
                        cderrno = errno;
                } else
                        descend = 1;
-       else
+       else
                descend = 0;
 
        /*
@@ -654,14 +674,19 @@ fts_build(sp, type)
 
        /* Read the directory, attaching each entry to the `link' pointer. */
        adjaddr = NULL;
-       for (head = tail = NULL, nitems = 0; dp = readdir(dirp);) {
+       head = tail = NULL;
+       nitems = 0;
+       while((dp = __readdir(dirp))) {
+               int namlen;
+
                if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
                        continue;
 
-               if ((p = fts_alloc(sp, dp->d_name, (int)dp->d_namlen)) == NULL)
+               namlen = _D_EXACT_NAMLEN (dp);
+               if ((p = fts_alloc(sp, dp->d_name, namlen)) == NULL)
                        goto mem1;
-               if (dp->d_namlen > maxlen) {
-                       if (fts_palloc(sp, (size_t)dp->d_namlen)) {
+               if (namlen > maxlen) {
+                       if (fts_palloc(sp, (size_t)namlen)) {
                                /*
                                 * No more memory for path or structures.  Save
                                 * errno, free up the current structure and the
@@ -671,8 +696,8 @@ mem1:                               saved_errno = errno;
                                if (p)
                                        free(p);
                                fts_lfree(head);
-                               (void)closedir(dirp);
-                               errno = saved_errno;
+                               (void)__closedir(dirp);
+                               __set_errno (saved_errno);
                                cur->fts_info = FTS_ERR;
                                SET(FTS_STOP);
                                return (NULL);
@@ -681,7 +706,7 @@ mem1:                               saved_errno = errno;
                        maxlen = sp->fts_pathlen - sp->fts_cur->fts_pathlen - 1;
                }
 
-               p->fts_pathlen = len + dp->d_namlen + 1;
+               p->fts_pathlen = len + namlen + 1;
                p->fts_parent = sp->fts_cur;
                p->fts_level = level;
 
@@ -693,9 +718,9 @@ mem1:                               saved_errno = errno;
                                p->fts_info = FTS_NSOK;
                        p->fts_accpath = cur->fts_accpath;
                } else if (nlinks == 0
-#ifdef DT_DIR
-                   || nlinks > 0 && 
-                   dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN
+#if defined DT_DIR && defined _DIRENT_HAVE_D_TYPE
+                   || (nlinks > 0 &&
+                       dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
 #endif
                    ) {
                        p->fts_accpath =
@@ -709,7 +734,7 @@ mem1:                               saved_errno = errno;
                        } else
                                p->fts_accpath = p->fts_name;
                        /* Stat it. */
-                       p->fts_info = fts_stat(sp, p, 0);
+                       p->fts_info = fts_stat(sp, dp, p, 0);
 
                        /* Decrement link count if applicable. */
                        if (nlinks > 0 && (p->fts_info == FTS_D ||
@@ -727,7 +752,7 @@ mem1:                               saved_errno = errno;
                }
                ++nitems;
        }
-       (void)closedir(dirp);
+       (void)__closedir(dirp);
 
        /*
         * If had to realloc the path, adjust the addresses for the rest
@@ -747,11 +772,15 @@ mem1:                             saved_errno = errno;
        }
 
        /*
-        * If descended after called from fts_children or called from
-        * fts_read and didn't find anything, get back.  If can't get
-        * back, done.
+        * If descended after called from fts_children or after called from
+        * fts_read and nothing found, get back.  At the root level we use
+        * the saved fd; if one of fts_open()'s arguments is a relative path
+        * to an empty directory, we wind up here with no other way back.  If
+        * can't get back, we're done.
         */
-       if (descend && (!nitems || type == BCHILD) && CHDIR(sp, "..")) {
+       if (descend && (type == BCHILD || !nitems) &&
+           (cur->fts_level == FTS_ROOTLEVEL ?
+            FCHDIR (sp, sp->fts_rfd) : CHDIR (sp, ".."))) {
                cur->fts_info = FTS_ERR;
                SET(FTS_STOP);
                return (NULL);
@@ -771,9 +800,11 @@ mem1:                              saved_errno = errno;
 }
 
 static u_short
-fts_stat(sp, p, follow)
+internal_function
+fts_stat(sp, dp, p, follow)
        FTS *sp;
        register FTSENT *p;
+       struct dirent *dp;
        int follow;
 {
        register FTSENT *t;
@@ -784,7 +815,20 @@ fts_stat(sp, p, follow)
 
        /* If user needs stat info, stat buffer already allocated. */
        sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
-       
+
+#if defined DT_WHT && defined S_IFWHT
+       /*
+        * Whited-out files don't really exist.  However, there's stat(2) file
+        * mask for them, so we set it so that programs (i.e., find) don't have
+        * to test FTS_W separately from other file types.
+        */
+       if (dp != NULL && dp->d_type == DT_WHT) {
+               memset(sbp, 0, sizeof(struct stat));
+               sbp->st_mode = S_IFWHT;
+               return (FTS_W);
+       }
+#endif
+
        /*
         * If doing a logical walk, or application requested FTS_FOLLOW, do
         * a stat(2).  If that fails, check for a non-existent symlink.  If
@@ -794,15 +838,15 @@ fts_stat(sp, p, follow)
                if (stat(p->fts_accpath, sbp)) {
                        saved_errno = errno;
                        if (!lstat(p->fts_accpath, sbp)) {
-                               errno = 0;
+                               __set_errno (0);
                                return (FTS_SLNONE);
-                       } 
+                       }
                        p->fts_errno = saved_errno;
                        goto err;
                }
        } else if (lstat(p->fts_accpath, sbp)) {
                p->fts_errno = errno;
-err:           bzero(sbp, sizeof(struct stat));
+err:           __bzero(sbp, sizeof(struct stat));
                return (FTS_NS);
        }
 
@@ -843,6 +887,7 @@ err:                bzero(sbp, sizeof(struct stat));
 }
 
 static FTSENT *
+internal_function
 fts_sort(sp, head, nitems)
        FTS *sp;
        FTSENT *head;
@@ -875,9 +920,10 @@ fts_sort(sp, head, nitems)
 }
 
 static FTSENT *
+internal_function
 fts_alloc(sp, name, namelen)
        FTS *sp;
-       char *name;
+       const char *name;
        register int namelen;
 {
        register FTSENT *p;
@@ -913,13 +959,14 @@ fts_alloc(sp, name, namelen)
 }
 
 static void
+internal_function
 fts_lfree(head)
        register FTSENT *head;
 {
        register FTSENT *p;
 
        /* Free a linked list of structures. */
-       while (p = head) {
+       while ((p = head)) {
                head = head->fts_link;
                free(p);
        }
@@ -929,9 +976,10 @@ fts_lfree(head)
  * Allow essentially unlimited paths; find, rm, ls should all work on any tree.
  * Most systems will allow creation of paths much longer than MAXPATHLEN, even
  * though the kernel won't resolve them.  Add the size (not just what's needed)
- * plus 256 bytes so don't realloc the path 2 bytes at a time. 
+ * plus 256 bytes so don't realloc the path 2 bytes at a time.
  */
 static int
+internal_function
 fts_palloc(sp, more)
        FTS *sp;
        size_t more;
@@ -946,6 +994,7 @@ fts_palloc(sp, more)
  * already returned.
  */
 static void
+internal_function
 fts_padjust(sp, addr)
        FTS *sp;
        void *addr;
@@ -969,6 +1018,7 @@ fts_padjust(sp, addr)
 }
 
 static size_t
+internal_function
 fts_maxarglen(argv)
        char * const *argv;
 {