8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / backup / dump / lftw.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */

/* LINTLIBRARY */
/*
 *      ftw - file tree walk
 *
 *      int ftw (path, fn, depth)  char *path; int (*fn)(); int depth;
 *
 *      Given a path name, ftw starts from the file given by that path
 *      name and visits each file and directory in the tree beneath
 *      that file.  If a single file has multiple links within the
 *      structure, it will be visited once for each such link.
 *      For each object visited, fn is called with three arguments.
 *      The first contains the path name of the object, the second
 *      contains a pointer to a stat buffer which will usually hold
 *      appropriate information for the object and the third will
 *      contain an integer value giving additional information:
 *
 *              FTW_F   The object is a file for which stat was
 *                      successful.  It does not guarantee that the
 *                      file can actually be read.
 *
 *              FTW_D   The object is a directory for which stat and
 *                      open for read were both successful.
 *
 *              FTW_DNR The object is a directory for which stat
 *                      succeeded, but which cannot be read.  Because
 *                      the directory cannot be read, fn will not be
 *                      called for any descendants of this directory.
 *
 *              FTW_NS  Stat failed on the object because of lack of
 *                      appropriate permission.  This indication will
 *                      be given, for example, for each file in a
 *                      directory with read but no execute permission.
 *                      Because stat failed, it is not possible to
 *                      determine whether this object is a file or a
 *                      directory.  The stat buffer passed to fn will
 *                      contain garbage.  Stat failure for any reason
 *                      other than lack of permission will be
 *                      considered an error and will cause ftw to stop
 *                      and return -1 to its caller.
 *
 *      If fn returns nonzero, ftw stops and returns the same value
 *      to its caller.  If ftw gets into other trouble along the way,
 *      it returns -1 and leaves an indication of the cause in errno.
 *
 *      The third argument to ftw does not limit the depth to which
 *      ftw will go.  Rather, it limits the depth to which ftw will
 *      go before it starts recycling file descriptors.  In general,
 *      it is necessary to use a file descriptor for each level of the
 *      tree, but they can be recycled for deep trees by saving the
 *      position, closing, re-opening, and seeking.  It is possible
 *      to start recycling file descriptors by sensing when we have
 *      run out, but in general this will not be terribly useful if
 *      fn expects to be able to open files.  We could also figure out
 *      how many file descriptors are available and guarantee a certain
 *      number to fn, but we would not know how many to guarantee,
 *      and we do not want to impose the extra overhead on a caller who
 *      knows how many are available without having to figure it out.
 *
 *      It is possible for ftw to die with a memory fault in the event
 *      of a file system so deeply nested that the stack overflows.
 */

#include <sys/fs/ufs_inode.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <malloc.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <ftw.h>

static int pwdfd;

static int lf_xftw(
        const char *,
        int (*)(const char *, const struct stat64 *, int),
        int,
        int (*)(const char *, struct stat64 *));

int
lf_lftw(
        const char *path,
        int (*fn)(const char *, const struct stat64 *, int),
        int depth)
{
        int rc;

        if ((pwdfd = open(".", O_RDONLY)) < 0) {
                return (-1);
        } else {
                rc = (lf_xftw(path, fn, depth, lstat64));
                (void) close(pwdfd);
                return (rc);
        }
}

static int
#ifdef __STDC__
lf_xftw(
        const char *path,
        int (*fn)(const char *, const struct stat64 *, int),
        int depth,
        int (*statfn)(const char *, struct stat64 *))
#else
lf_xftw(char *path, int (*fn)(), int depth, int (*statfn)())
#endif
{
        int n;
        int rc, sublen, saverr, attrfd;
        DIR *dirp;
        char *subpath, *component;
        struct stat64 sb;
        struct dirent *dp;
        extern dev_t partial_dev;

        /*
         * Try to get file status.
         * If unsuccessful, errno will say why.
         */
        if ((*statfn)(path, &sb) < 0)
                return (errno == EACCES? (*fn)(path, &sb, FTW_NS): -1);
        /*
         *      The stat succeeded, so we know the object exists.
         *      Make sure it is not a mount point for another filesystem.
         *      The following check must be made here because:
         *
         *              + namefs can be mounted on anything, but a directory
         *              + all other filesystems must be mounted on a directory
         */
        if (sb.st_dev != partial_dev) {
                return (0);
        }
        /*
         *      Check for presence of attributes on file
         */
        if (pathconf(path, _PC_XATTR_EXISTS) == 1) {
                attrfd = attropen64(path, ".", O_RDONLY|O_NONBLOCK);
        } else {
                attrfd = -1;
        }
        /*
         *      If not a directory, call the user function and return.
         */
        if ((sb.st_mode & S_IFMT) != S_IFDIR &&
            (sb.st_mode & IFMT) != IFATTRDIR) {
                rc = (*fn)(path, &sb, FTW_F);
                if (rc == 0 && attrfd != -1) {
                        (void) fchdir(attrfd);
                        rc = lf_xftw(".", fn, depth-1, statfn);
                        (void) fchdir(pwdfd);
                        (void) close(attrfd);
                }
                return (rc);
        }
        /*
         *      The object was a directory and not a mount point.
         *
         *      Open a file to read the directory
         */
        dirp = opendir(path);

        /*
         *      Call the user function, telling it whether
         *      the directory can be read.  If it can't be read
         *      call the user function or indicate an error,
         *      depending on the reason it couldn't be read.
         */
        if (dirp == NULL)
                rc = (errno == EACCES? (*fn)(path, &sb, FTW_DNR): -1);
        else
                rc = (*fn)(path, &sb, FTW_D);
        /*
         *      If the directory has attributes, process the
         *      attributes before processing the directory contents.
         */
        if (rc == 0 && attrfd != -1) {
                (void) fchdir(attrfd);
                rc = lf_xftw(".", fn, depth-1, statfn);
                (void) fchdir(pwdfd);
                (void) close(attrfd);
        }
        if (rc != 0 || dirp == NULL)
                return (rc);

        /* Allocate a buffer to hold generated pathnames. */
        /* LINTED: the length will fit into a signed integer */
        n = (int)strlen(path);
        sublen = n + MAXNAMLEN + 1; /* +1 for appended / */
        subpath = malloc((unsigned)(sublen+1)); /* +1 for NUL */
        if (subpath == NULL) {
                saverr = errno;
                (void) closedir(dirp);
                errno = saverr;
                return (-1);
        }

        /* Create a prefix to which we will append component names */
        (void) strcpy(subpath, path);
        if (subpath[0] != '\0' && subpath[n-1] != '/')
                subpath[n++] = '/';
        component = &subpath[n];
        /* LINTED: result will fit into a 32-bit int */
        sublen -= component - subpath;

        /*
         *      Read the directory one component at a time.
         *      We must ignore "." and "..", but other than that,
         *      just create a path name and call self to check it out.
         */
        while ((dp = readdir(dirp)) != NULL) {
                if (strcmp(dp->d_name, ".") != 0 &&
                    strcmp(dp->d_name, "..") != 0) {
                        long here;

                        /* Append component name to the working path */
                        (void) strncpy(component, dp->d_name, sublen);
                        component[sublen - 1] = '\0';

                        /*
                         *      If we are about to exceed our depth,
                         *      remember where we are and close a file.
                         */
                        if (depth <= 1) {
                                here = telldir(dirp);
                                (void) closedir(dirp);
                        }

                        /*
                         *      Do a recursive call to process the file.
                         *      (watch this, sports fans)
                         */
                        rc = lf_xftw(subpath, fn, depth-1, statfn);
                        if (rc != 0) {
                                free(subpath);
                                if (depth > 1)
                                        (void) closedir(dirp);
                                return (rc);
                        }

                        /*
                         *      If we closed the file, try to reopen it.
                         */
                        if (depth <= 1) {
                                dirp = opendir(path);
                                if (dirp == NULL) {
                                        free(subpath);
                                        return (-1);
                                }
                                seekdir(dirp, here);
                        }
                }
        }

        /*
         *      We got out of the subdirectory loop.  The return from
         *      the final readdir is in dp.  Clean up.
         */
        free(subpath);
        (void) closedir(dirp);
        return (0);
}