Update.
[kopensolaris-gnu/glibc.git] / io / fts.c
index cfc8fa6..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,15 +53,16 @@ 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); \
@@ -73,13 +70,13 @@ static u_short       fts_stat __P((FTS *, FTSENT *, int));
                           _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 */
@@ -107,7 +104,7 @@ fts_open(argv, options, compar)
        /* Allocate/initialize the stream */
        if ((sp = malloc((u_int)sizeof(FTS))) == NULL)
                return (NULL);
-       bzero(sp, sizeof(FTS));
+       __bzero(sp, sizeof(FTS));
        sp->fts_compar = (int (*) __P((const void *, const void *))) compar;
        sp->fts_options = options;
 
@@ -142,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)
@@ -185,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);
@@ -229,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
@@ -253,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) {
                __set_errno (saved_errno);
-               return (-1);
+               retval = -1;
        }
-       return (0);
+
+       /* Free up the stream pointer. */
+       free (sp);
+
+       return retval;
 }
 
 /*
@@ -298,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);
        }
 
@@ -310,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);
        }
 
@@ -324,9 +325,9 @@ 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;
@@ -374,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);
 
                /*
@@ -398,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;
                }
 
@@ -445,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);
+                       (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);
@@ -542,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);
 }
 
@@ -566,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 dirbuf, *dp;
+       struct dirent *dp;
        register FTSENT *p, *head;
        register int nitems;
        FTSENT *cur, *tail;
@@ -578,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;
@@ -586,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;
@@ -627,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;
@@ -636,7 +650,7 @@ fts_build(sp, type)
                        cderrno = errno;
                } else
                        descend = 1;
-       else
+       else
                descend = 0;
 
        /*
@@ -660,8 +674,9 @@ fts_build(sp, type)
 
        /* Read the directory, attaching each entry to the `link' pointer. */
        adjaddr = NULL;
-       for (head = tail = NULL, nitems = 0;
-            __readdir_r (dirp, &dirbuf, &dp) >= 0;) {
+       head = tail = NULL;
+       nitems = 0;
+       while((dp = __readdir(dirp))) {
                int namlen;
 
                if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
@@ -681,7 +696,7 @@ mem1:                               saved_errno = errno;
                                if (p)
                                        free(p);
                                fts_lfree(head);
-                               (void)closedir(dirp);
+                               (void)__closedir(dirp);
                                __set_errno (saved_errno);
                                cur->fts_info = FTS_ERR;
                                SET(FTS_STOP);
@@ -703,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 =
@@ -719,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 ||
@@ -737,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
@@ -757,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);
@@ -781,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;
@@ -795,6 +816,19 @@ 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
@@ -812,7 +846,7 @@ fts_stat(sp, p, follow)
                }
        } 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);
        }
 
@@ -853,6 +887,7 @@ err:                bzero(sbp, sizeof(struct stat));
 }
 
 static FTSENT *
+internal_function
 fts_sort(sp, head, nitems)
        FTS *sp;
        FTSENT *head;
@@ -885,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;
@@ -923,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);
        }
@@ -942,6 +979,7 @@ fts_lfree(head)
  * 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;
@@ -956,6 +994,7 @@ fts_palloc(sp, more)
  * already returned.
  */
 static void
+internal_function
 fts_padjust(sp, addr)
        FTS *sp;
        void *addr;
@@ -979,6 +1018,7 @@ fts_padjust(sp, addr)
 }
 
 static size_t
+internal_function
 fts_maxarglen(argv)
        char * const *argv;
 {