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) == (char *)0) {
		(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);
}