Merge commit '00f1a4f432b3d8aad1aa270e91c44c57f03ef407'

[unleashed.git] / usr / src / cmd / chown / chown.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 * chown [-fhR] uid[:gid] file ...
 * chown -R [-f] [-H|-L|-P] uid[:gid] file ...
 * chown -s [-fhR] ownersid[:groupsid] file ...
 * chown -s -R [-f] [-H|-L|-P] ownersid[:groupsid] file ...
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/avl.h>
#include <pwd.h>
#include <grp.h>
#include <unistd.h>
#include <locale.h>
#include <errno.h>
#include <libcmdutils.h>
#include <aclutils.h>

static struct           passwd  *pwd;
static struct           group   *grp;
static struct           stat    stbuf;
static uid_t            uid = (uid_t)-1;
static gid_t            gid = (gid_t)-1;
static int              status = 0;     /* total number of errors received */
static int              hflag = 0,
                        rflag = 0,
                        fflag = 0,
                        Hflag = 0,
                        Lflag = 0,
                        Pflag = 0,
                        sflag = 0;
static avl_tree_t       *tree;

static int              Perror(char *);
static int              isnumber(char *);
static void             chownr(char *, uid_t, gid_t);
static void             usage();

#ifdef XPG4
/*
 * Check to see if we are to follow symlinks specified on the command line.
 * This assumes we've already checked to make sure neither -h or -P was
 * specified, so we are just looking to see if -R -H, or -R -L was specified,
 * or, since -R has the same behavior as -R -L, if -R was specified by itself.
 * Therefore, all we really need to check for is if -R was specified.
 */
#define FOLLOW_CL_LINKS (rflag)
#else
/*
 * Check to see if we are to follow symlinks specified on the command line.
 * This assumes we've already checked to make sure neither -h or -P was
 * specified, so we are just looking to see if -R -H, or -R -L was specified.
 * Note: -R by itself will change the ownership of a directory referenced by a
 * symlink however it will now follow the symlink to any other part of the
 * file hierarchy.
 */
#define FOLLOW_CL_LINKS (rflag && (Hflag || Lflag))
#endif

#ifdef XPG4
/*
 * Follow symlinks when traversing directories.  Since -R behaves the
 * same as -R -L, we always want to follow symlinks to other parts
 * of the file hierarchy unless -H was specified.
 */
#define FOLLOW_D_LINKS  (!Hflag)
#else
/*
 * Follow symlinks when traversing directories.  Only follow symlinks
 * to other parts of the file hierarchy if -L was specified.
 */
#define FOLLOW_D_LINKS  (Lflag)
#endif

#define CHOWN(f, u, g)  if (chown(f, u, g) < 0) { \
                                status += Perror(f); \
                        }
#define LCHOWN(f, u, g) if (lchown(f, u, g) < 0) { \
                                status += Perror(f); \
                        }


int
main(int argc, char *argv[])
{
        int c;
        int ch;
        char *grpp;                     /* pointer to group name arg */
        extern int optind;
        int errflg = 0;

        (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)               /* Should be defined by cc -D */
#define TEXT_DOMAIN     "SYS_TEST"      /* Use this only if it weren't */
#endif
        (void) textdomain(TEXT_DOMAIN);

        while ((ch = getopt(argc, argv, "hRfHLPs")) != EOF) {
                switch (ch) {
                case 'h':
                        hflag++;
                        break;

                case 'R':
                        rflag++;
                        break;

                case 'f':
                        fflag++;
                        break;

                case 'H':
                        /*
                         * If more than one of -H, -L, and -P
                         * are specified, only the last option
                         * specified determines the behavior of
                         * chown.
                         */
                        Lflag = Pflag = 0;
                        Hflag++;
                        break;

                case 'L':
                        Hflag = Pflag = 0;
                        Lflag++;
                        break;

                case 'P':
                        Hflag = Lflag = 0;
                        Pflag++;
                        break;

                case 's':
                        sflag++;
                        break;

                default:
                        errflg++;
                        break;
                }
        }
        /*
         * Check for sufficient arguments
         * or a usage error.
         */

        argc -= optind;
        argv = &argv[optind];

        if (errflg || (argc < 2) ||
            ((Hflag || Lflag || Pflag) && !rflag) ||
            ((Hflag || Lflag || Pflag) && hflag)) {
                usage();
        }

        /*
         * POSIX.2
         * Check for owner[:group]
         */
        if ((grpp = strchr(argv[0], ':')) != NULL) {
                *grpp++ = 0;

                if (sflag) {
                        if (sid_to_id(grpp, B_FALSE, &gid)) {
                                (void) fprintf(stderr, gettext(
                                    "chown: invalid owning group sid %s\n"),
                                    grpp);
                                exit(2);
                        }
                } else if ((grp = getgrnam(grpp)) != NULL) {
                        gid = grp->gr_gid;
                } else {
                        if (isnumber(grpp)) {
                                errno = 0;
                                gid = (gid_t)strtoul(grpp, NULL, 10);
                                if (errno != 0) {
                                        if (errno == ERANGE) {
                                                (void) fprintf(stderr, gettext(
                                                "chown: group id too large\n"));
                                                        exit(2);
                                        } else {
                                                (void) fprintf(stderr, gettext(
                                                "chown: invalid group id\n"));
                                                exit(2);
                                        }
                                }
                        } else {
                                (void) fprintf(stderr, gettext(
                                    "chown: unknown group id %s\n"), grpp);
                                exit(2);
                        }
                }
        }

        if (sflag) {
                if (sid_to_id(argv[0], B_TRUE, &uid)) {
                        (void) fprintf(stderr, gettext(
                            "chown: invalid owner sid %s\n"), argv[0]);
                        exit(2);
                }
        } else if ((pwd = getpwnam(argv[0])) != NULL) {
                uid = pwd->pw_uid;
        } else {
                if (isnumber(argv[0])) {
                        errno = 0;
                        uid = (uid_t)strtoul(argv[0], NULL, 10);
                        if (errno != 0) {
                                if (errno == ERANGE) {
                                        (void) fprintf(stderr, gettext(
                                        "chown: user id too large\n"));
                                        exit(2);
                                } else {
                                        (void) fprintf(stderr, gettext(
                                        "chown: invalid user id\n"));
                                        exit(2);
                                }
                        }
                } else {
                        (void) fprintf(stderr, gettext(
                        "chown: unknown user id %s\n"), argv[0]);
                        exit(2);
                }
        }

        for (c = 1; c < argc; c++) {
                tree = NULL;
                if (lstat(argv[c], &stbuf) < 0) {
                        status += Perror(argv[c]);
                        continue;
                }
                if (rflag && ((stbuf.st_mode & S_IFMT) == S_IFLNK)) {
                        if (hflag || Pflag) {
                                /*
                                 * Change the ownership of the symlink
                                 * specified on the command line.
                                 * Don't follow the symbolic link to
                                 * any other part of the file hierarchy.
                                 */
                                LCHOWN(argv[c], uid, gid);
                        } else {
                                struct stat stbuf2;
                                if (stat(argv[c], &stbuf2) < 0) {
                                        status += Perror(argv[c]);
                                        continue;
                                }
                                /*
                                 * We know that we are to change the
                                 * ownership of the file referenced by the
                                 * symlink specified on the command line.
                                 * Now check to see if we are to follow
                                 * the symlink to any other part of the
                                 * file hierarchy.
                                 */
                                if (FOLLOW_CL_LINKS) {
                                        if ((stbuf2.st_mode & S_IFMT)
                                            == S_IFDIR) {
                                                /*
                                                 * We are following symlinks so
                                                 * traverse into the directory.
                                                 * Add this node to the search
                                                 * tree so we don't get into an
                                                 * endless loop.
                                                 */
                                                if (add_tnode(&tree,
                                                    stbuf2.st_dev,
                                                    stbuf2.st_ino) == 1) {
                                                        chownr(argv[c],
                                                            uid, gid);
                                                } else {
                                                        /*
                                                         * Error occurred.
                                                         * rc can't be 0
                                                         * as this is the first
                                                         * node to be added to
                                                         * the search tree.
                                                         */
                                                        status += Perror(
                                                            argv[c]);
                                                }
                                        } else {
                                                /*
                                                 * Change the user ID of the
                                                 * file referenced by the
                                                 * symlink.
                                                 */
                                                CHOWN(argv[c], uid, gid);
                                        }
                                } else {
                                        /*
                                         * Change the user ID of the file
                                         * referenced by the symbolic link.
                                         */
                                        CHOWN(argv[c], uid, gid);
                                }
                        }
                } else if (rflag && ((stbuf.st_mode & S_IFMT) == S_IFDIR)) {
                        /*
                         * Add this node to the search tree so we don't
                         * get into a endless loop.
                         */
                        if (add_tnode(&tree, stbuf.st_dev,
                            stbuf.st_ino) == 1) {
                                chownr(argv[c], uid, gid);
                        } else {
                                /*
                                 * An error occurred while trying
                                 * to add the node to the tree.
                                 * Continue on with next file
                                 * specified.  Note: rc shouldn't
                                 * be 0 as this was the first node
                                 * being added to the search tree.
                                 */
                                status += Perror(argv[c]);
                        }
                } else if (hflag || Pflag) {
                        LCHOWN(argv[c], uid, gid);
                } else {
                        CHOWN(argv[c], uid, gid);
                }
        }
        return (status);
}

/*
 * chownr() - recursive chown()
 *
 * Recursively chowns the input directory then its contents.  rflag must
 * have been set if chownr() is called.  The input directory should not
 * be a sym link (this is handled in the calling routine).  In
 * addition, the calling routine should have already added the input
 * directory to the search tree so we do not get into endless loops.
 * Note: chownr() doesn't need a return value as errors are reported
 * through the global "status" variable.
 */
static void
chownr(char *dir, uid_t uid, gid_t gid)
{
        DIR *dirp;
        struct dirent *dp;
        struct stat st, st2;
        char savedir[1024];

        if (getcwd(savedir, 1024) == NULL) {
                (void) Perror("getcwd");
                exit(255);
        }

        /*
         * Attempt to chown the directory, however don't return if we
         * can't as we still may be able to chown the contents of the
         * directory.  Note: the calling routine resets the SUID bits
         * on this directory so we don't have to perform an extra 'stat'.
         */
        CHOWN(dir, uid, gid);

        if (chdir(dir) < 0) {
                status += Perror(dir);
                return;
        }
        if ((dirp = opendir(".")) == NULL) {
                status += Perror(dir);
                return;
        }
        for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
                if (strcmp(dp->d_name, ".") == 0 ||     /* skip . and .. */
                    strcmp(dp->d_name, "..") == 0) {
                        continue;
                }
                if (lstat(dp->d_name, &st) < 0) {
                        status += Perror(dp->d_name);
                        continue;
                }
                if ((st.st_mode & S_IFMT) == S_IFLNK) {
                        if (hflag || Pflag) {
                                /*
                                 * Change the ownership of the symbolic link
                                 * encountered while traversing the
                                 * directory.  Don't follow the symbolic
                                 * link to any other part of the file
                                 * hierarchy.
                                 */
                                LCHOWN(dp->d_name, uid, gid);
                        } else {
                                if (stat(dp->d_name, &st2) < 0) {
                                        status += Perror(dp->d_name);
                                        continue;
                                }
                                /*
                                 * We know that we are to change the
                                 * ownership of the file referenced by the
                                 * symlink encountered while traversing
                                 * the directory.  Now check to see if we
                                 * are to follow the symlink to any other
                                 * part of the file hierarchy.
                                 */
                                if (FOLLOW_D_LINKS) {
                                        if ((st2.st_mode & S_IFMT) == S_IFDIR) {
                                                /*
                                                 * We are following symlinks so
                                                 * traverse into the directory.
                                                 * Add this node to the search
                                                 * tree so we don't get into an
                                                 * endless loop.
                                                 */
                                                int rc;
                                                if ((rc = add_tnode(&tree,
                                                    st2.st_dev,
                                                    st2.st_ino)) == 1) {
                                                        chownr(dp->d_name,
                                                            uid, gid);
                                                } else if (rc == 0) {
                                                        /* already visited */
                                                        continue;
                                                } else {
                                                        /*
                                                         * An error occurred
                                                         * while trying to add
                                                         * the node to the tree.
                                                         */
                                                        status += Perror(
                                                            dp->d_name);
                                                        continue;
                                                }
                                        } else {
                                                /*
                                                 * Change the user id of the
                                                 * file referenced by the
                                                 * symbolic link.
                                                 */
                                                CHOWN(dp->d_name, uid, gid);
                                        }
                                } else {
                                        /*
                                         * Change the user id of the file
                                         * referenced by the symbolic link.
                                         */
                                        CHOWN(dp->d_name, uid, gid);
                                }
                        }
                } else if ((st.st_mode & S_IFMT) == S_IFDIR) {
                        /*
                         * Add this node to the search tree so we don't
                         * get into a endless loop.
                         */
                        int rc;
                        if ((rc = add_tnode(&tree, st.st_dev,
                            st.st_ino)) == 1) {
                                chownr(dp->d_name, uid, gid);
                        } else if (rc == 0) {
                                /* already visited */
                                continue;
                        } else {
                                /*
                                 * An error occurred while trying
                                 * to add the node to the search tree.
                                 */
                                status += Perror(dp->d_name);
                                continue;
                        }
                } else {
                        CHOWN(dp->d_name, uid, gid);
                }
        }

        (void) closedir(dirp);
        if (chdir(savedir) < 0) {
                (void) fprintf(stderr, gettext(
                    "chown: can't change back to %s\n"), savedir);
                exit(255);
        }
}

static int
isnumber(char *s)
{
        int c;

        while ((c = *s++) != '\0')
                if (!isdigit(c))
                        return (0);
        return (1);
}

static int
Perror(char *s)
{
        if (!fflag) {
                (void) fprintf(stderr, "chown: ");
                perror(s);
        }
        return (!fflag);
}

static void
usage()
{
        (void) fprintf(stderr, gettext(
            "usage:\n"
            "\tchown [-fhR] owner[:group] file...\n"
            "\tchown -R [-f] [-H|-L|-P] owner[:group] file...\n"
            "\tchown -s [-fhR] ownersid[:groupsid] file...\n"
            "\tchown -s -R [-f] [-H|-L|-P] ownersid[:groupsid] file...\n"));
        exit(2);
}