chown.c revision f48205be61a214698b763ff550ab9e657525104c
/*
* 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
* 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 2007 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 ...
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <dirent.h>
#include <string.h>
#include <pwd.h>
#include <grp.h>
#include <unistd.h>
#include <locale.h>
#include <errno.h>
#include <libcmdutils.h>
static int status = 0; /* total number of errors received */
static int hflag = 0,
rflag = 0,
fflag = 0,
Hflag = 0,
Lflag = 0,
Pflag = 0;
static avl_tree_t *tree;
static int Perror(char *);
static int isnumber(char *);
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.
*/
#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
}
}
int
{
int c;
int ch;
char *grpp; /* pointer to group name arg */
extern int optind;
int errflg = 0;
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#endif
(void) textdomain(TEXT_DOMAIN);
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.
*/
Hflag++;
break;
case 'L':
Lflag++;
break;
case 'P':
Pflag++;
break;
default:
errflg++;
break;
}
}
/*
* Check for sufficient arguments
* or a usage error.
*/
usage();
}
/*
* POSIX.2
* Check for owner[:group]
*/
*grpp++ = 0;
} else {
errno = 0;
if (errno != 0) {
"chown: group id too large\n"));
exit(2);
} else {
"chown: invalid group id\n"));
exit(2);
}
}
} else {
"chown: unknown group id %s\n"), grpp);
exit(2);
}
}
}
} else {
errno = 0;
if (errno != 0) {
"chown: user id too large\n"));
exit(2);
} else {
"chown: invalid user id\n"));
exit(2);
}
}
} else {
"chown: unknown user id %s\n"), argv[0]);
exit(2);
}
}
for (c = 1; c < argc; c++) {
continue;
}
/*
* 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.
*/
} else {
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) {
== 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.
*/
} else {
/*
* Error occurred.
* rc can't be 0
* as this is the first
* node to be added to
* the search tree.
*/
argv[c]);
}
} else {
/*
* Change the user ID of the
* file referenced by the
* symlink.
*/
}
} else {
/*
* Change the user ID of the file
* referenced by the symbolic link.
*/
}
}
/*
* Add this node to the search tree so we don't
* get into a endless loop.
*/
} 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.
*/
}
} else {
}
}
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
{
char savedir[1024];
(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'.
*/
return;
}
return;
}
continue;
}
continue;
}
/*
* 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.
*/
} else {
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) {
/*
* 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;
} else if (rc == 0) {
/* already visited */
continue;
} else {
/*
* An error occurred
* while trying to add
* the node to the tree.
*/
continue;
}
} else {
/*
* Change the user id of the
* file referenced by the
* symbolic link.
*/
}
} else {
/*
* Change the user id of the file
* referenced by the symbolic link.
*/
}
}
/*
* Add this node to the search tree so we don't
* get into a endless loop.
*/
int rc;
} else if (rc == 0) {
/* already visited */
continue;
} else {
/*
* An error occurred while trying
* to add the node to the search tree.
*/
continue;
}
} else {
}
}
"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) {
perror(s);
}
return (!fflag);
}
static void
usage()
{
"usage:\n"
"\tchown [-fhR] owner[:group] file...\n"
"\tchown -R [-f] [-H|-L|-P] owner[:group] file...\n"));
exit(2);
}