cmd/filesync/main.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * module:
 *	main.c
 *
 * purpose:
 *	argument handling and top level dispatch
 *
 * contents:
 *	main		argument handling and main loop
 *	usage		(static) print out usage message
 *	confirm		prompt the user for a confirmation and get it
 *	nomem		fatal error handler for malloc failures
 *	findfiles	(static) locate our baseline and rules files
 *	cleanup		(static) unlock baseline and delete temp file
 *	check_access	(static) do we have adequate access to a file/directory
 *	whoami		(static) get uid/gid/umask
 */

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

#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/stat.h>

#include "filesync.h"
#include "database.h"
#include "messages.h"
#include "debug.h"

/*
 * local routines in this module:
 */
static errmask_t findfiles();		/* find rule and baseline files	*/
static void cleanup(int);		/* cleanup locks and temps	*/
static errmask_t check_access(char *, int *); /* check access to file	*/
static void whoami();			/* gather information about me	*/
static void usage(void);		/* general usage		*/


/*
 * globals exported to the rest of the program
 */
bool_t	opt_mtime;	/* preserve modification times on propagations	*/
bool_t	opt_notouch;	/* don't actually make any changes		*/
bool_t	opt_quiet;	/* disable reconciliation command output	*/
bool_t	opt_verbose;	/* enable analysis descriptions			*/
side_t	opt_force;	/* designated winner for conflicts		*/
side_t	opt_oneway;	/* one way only propagation			*/
side_t	opt_onesided;	/* permit one-sided evaluation			*/
bool_t	opt_everything;	/* everything must agree (modes/uid/gid)	*/
bool_t	opt_yes;	/* pre-confirm massive deletions are OK		*/
bool_t	opt_acls;	/* always scan for acls on all files		*/
bool_t	opt_errors;	/* simulate errors on specified files		*/
bool_t	opt_halt;	/* halt on propagation errors			*/
dbgmask_t opt_debug;	/* debug mask					*/

uid_t	my_uid;		/* default UID for files I create		*/
gid_t	my_gid;		/* default GID for files I create		*/

static char *file_rules; /* name of rules file				*/
static char *file_base;	/* name of baseline file			*/

static int new_baseline; /* are we creating a new baseline		*/
static int new_rules;	/* are we creating a new rules file		*/
static int my_umask;	/* default UMASK for files I create		*/
static int lockfd;	/* file descriptor for locking baseline		*/

static char *rlist[MAX_RLIST];
static int num_restrs = 0;

/*
 * routine:
 *	main
 *
 * purpose:
 *	argument processing and primary dispatch
 *
 * returns:
 *	error codes per filesync.1 (ERR_* in filesync.h)
 *
 * notes:
 *	read filesync.1 in order to understand the argument processing
 *
 *	most of the command line options just set some opt_ global
 *	variable that is later looked at by the code that actually
 *	implements the features.  Only file names are really processed
 *	in this routine.
 */
int
main(int argc, char **argv)
{	int i;
	int c;
	errmask_t errs = ERR_OK;
	int do_prune = 0;
	char *srcname = 0;
	char *dstname = 0;
	struct base *bp;

	/* keep the error messages simple	*/
	argv[0] = "filesync";

	/* gather together all of the options	*/
	while ((c = getopt(argc, argv, "AaehmnqvyD:E:r:s:d:f:o:")) != EOF)
		switch (c) {
			case 'a':	/* always scan for acls	*/
				opt_acls = TRUE;
				break;
			case 'e':	/* everything agrees	*/
				opt_everything = TRUE;
				break;
			case 'h':	/* halt on error	*/
				opt_halt = TRUE;
				break;
			case 'm':	/* preserve modtimes	*/
				opt_mtime = TRUE;
				break;
			case 'n':	/* notouch		*/
				opt_notouch = TRUE;
				break;
			case 'q':	/* quiet		*/
				opt_quiet = TRUE;
				break;
			case 'v':	/* verbose		*/
				opt_verbose = TRUE;
				break;
			case 'y':	/* yes			*/
				opt_yes = TRUE;
				break;
			case 'D':	/* debug options	*/
				if (!isdigit(optarg[0])) {
					dbg_usage();
					exit(ERR_INVAL);
				}
				opt_debug |= strtol(optarg, (char **)NULL, 0);
				break;

			case 'E':	/* error simulation	*/
				if (dbg_set_error(optarg)) {
					err_usage();
					exit(ERR_INVAL);
				}
				opt_errors = TRUE;
				break;

			case 'f':	/* force conflict resolution	*/
				switch (optarg[0]) {
					case 's':
						opt_force = OPT_SRC;
						break;
					case 'd':
						opt_force = OPT_DST;
						break;
					case 'o':
						opt_force = OPT_OLD;
						break;
					case 'n':
						opt_force = OPT_NEW;
						break;
					default:
						fprintf(stderr,
							gettext(ERR_badopt),
							c, optarg);
						errs |= ERR_INVAL;
						break;
				}
				break;

			case 'o':	/* one way propagation		*/
				switch (optarg[0]) {
					case 's':
						opt_oneway = OPT_SRC;
						break;
					case 'd':
						opt_oneway = OPT_DST;
						break;
					default:
						fprintf(stderr,
							gettext(ERR_badopt),
							c, optarg);
						errs |= ERR_INVAL;
						break;
				}
				break;

			case 'r':	/* restricted reconciliation	*/
				if (num_restrs < MAX_RLIST)
					rlist[ num_restrs++ ] = optarg;
				else {
					fprintf(stderr, gettext(ERR_tomany),
						MAX_RLIST);
					errs |= ERR_INVAL;
				}
				break;

			case 's':
				if ((srcname = qualify(optarg)) == 0)
					errs |= ERR_MISSING;
				break;

			case 'd':
				if ((dstname = qualify(optarg)) == 0)
					errs |= ERR_MISSING;
				break;

			default:
			case '?':
				errs |= ERR_INVAL;
				break;
		}

	if (opt_debug & DBG_MISC)
		fprintf(stderr, "MISC: DBG=%s\n", showflags(dbgmap, opt_debug));

	/* if we have file names, we need a source and destination */
	if (optind < argc) {
		if (srcname == 0) {
			fprintf(stderr, gettext(ERR_nosrc));
			errs |= ERR_INVAL;
		}
		if (dstname == 0) {
			fprintf(stderr, gettext(ERR_nodst));
			errs |= ERR_INVAL;
		}
	}

	/* check for simple usage errors	*/
	if (errs & ERR_INVAL) {
		usage();
		exit(errs);
	}

	/* locate our baseline and rules files	*/
	if (c = findfiles())
		exit(c);

	/* figure out file creation defaults	*/
	whoami();

	/* read in our initial baseline		*/
	if (!new_baseline && (c = read_baseline(file_base)))
		errs |= c;

	/* read in the rules file if we need or have rules	*/
	if (optind >= argc && new_rules) {
		fprintf(stderr, ERR_nonames);
		errs |= ERR_INVAL;
	} else if (!new_rules)
		errs |= read_rules(file_rules);

	/* if anything has failed with our setup, go no further	*/
	if (errs) {
		cleanup(errs);
		exit(errs);
	}

	/*
	 * figure out whether or not we are willing to do a one-sided
	 * analysis (where we don't even look at the other side.  This
	 * is an "I'm just curious what has changed" query, and we are
	 * only willing to do it if:
	 *	we aren't actually going to do anything
	 *	we have a baseline we can compare against
	 * otherwise, we are going to insist on being able to access
	 * both the source and destination.
	 */
	if (opt_notouch && !new_baseline)
		opt_onesided = opt_oneway;

	/*
	 * there are two interested usage scenarios:
	 *	file names specified
	 *		create new rules for the specified files
	 *		evaulate and reconcile only the specified files
	 *	no file names specified
	 *		use already existing rules
	 *		consider restricting them to specified subdirs/files
	 */
	if (optind < argc) {
		/* figure out what base pair we're working on	*/
		bp = add_base(srcname, dstname);

		/* perverse default rules to avoid trouble	*/
		if (new_rules) {
			errs |= add_ignore(0, SUFX_RULES);
			errs |= add_ignore(0, SUFX_BASE);
		}

		/* create include rules for each file/dir arg	*/
		while (optind < argc)
			errs |= add_include(bp, argv[ optind++ ]);

		/*
		 * evaluate the specified base on each side,
		 * being careful to limit evaulation to new rules
		 */
		errs |= evaluate(bp, OPT_SRC, TRUE);
		errs |= evaluate(bp, OPT_DST, TRUE);
	} else {
		/* note any possible evaluation restrictions	*/
		for (i = 0; i < num_restrs; i++)
			errs |= add_restr(rlist[i]);

		/*
		 * we can only prune the baseline file if we have done
		 * a complete (unrestricted) analysis.
		 */
		if (i == 0)
			do_prune = 1;

		/* evaulate each base on each side		*/
		for (bp = bases; bp; bp = bp->b_next) {
			errs |= evaluate(bp, OPT_SRC, FALSE);
			errs |= evaluate(bp, OPT_DST, FALSE);
		}
	}

	/* if anything serious happened, skip reconciliation	*/
	if (errs & ERR_FATAL) {
		cleanup(errs);
		exit(errs);
	}

	/* analyze and deal with the differenecs		*/
	errs |= analyze();

	/* see if there is any dead-wood in the baseline	*/
	if (do_prune) {
		c = prune();

		if (c > 0 && opt_verbose)
			fprintf(stdout, V_prunes, c);
	}

	/* print out a final summary				*/
	summary();

	/* update the rules and baseline files (if needed)	*/
	(void) umask(my_umask);
	errs |= write_baseline(file_base);
	errs |= write_rules(file_rules);

	if (opt_debug & DBG_MISC)
		fprintf(stderr, "MISC: EXIT=%s\n", showflags(errmap, errs));

	/* just returning ERR_RESOLVABLE upsets some people	*/
	if (errs == ERR_RESOLVABLE && !opt_notouch)
		errs = 0;

	/* all done	*/
	cleanup(0);
	return (errs);
}


/*
 * routine:
 *	usage
 *
 * purpose:
 *	print out a usage message
 *
 * parameters:
 *	none
 *
 * returns:
 *	none
 *
 * note:
 *	the -D and -E switches are for development/test/support
 *	use only and do not show up in the general usage message.
 */
static void
usage(void)
{
	fprintf(stderr, "%s\t%s %s\n", gettext(ERR_usage), "filesync",
					gettext(USE_simple));
	fprintf(stderr, "\t%s %s\n", "filesync", gettext(USE_all));
	fprintf(stderr, "\t-a .......... %s\n", gettext(USE_a));
	fprintf(stderr, "\t-e .......... %s\n", gettext(USE_e));
	fprintf(stderr, "\t-h .......... %s\n", gettext(USE_h));
	fprintf(stderr, "\t-m .......... %s\n", gettext(USE_m));
	fprintf(stderr, "\t-n .......... %s\n", gettext(USE_n));
	fprintf(stderr, "\t-q .......... %s\n", gettext(USE_q));
	fprintf(stderr, "\t-v .......... %s\n", gettext(USE_v));
	fprintf(stderr, "\t-y .......... %s\n", gettext(USE_y));
	fprintf(stderr, "\t-s dir ...... %s\n", gettext(USE_s));
	fprintf(stderr, "\t-d dir ...... %s\n", gettext(USE_d));
	fprintf(stderr, "\t-r dir ...... %s\n", gettext(USE_r));
	fprintf(stderr, "\t-f [sdon].... %s\n", gettext(USE_f));
	fprintf(stderr, "\t-o src/dst... %s\n", gettext(USE_o));
}

/*
 * routine:
 *	confirm
 *
 * purpose:
 *	to confirm that the user is willing to do something dangerous
 *
 * parameters:
 *	warning message to be printed
 *
 * returns:
 * 	void
 *
 * notes:
 *	if this is a "notouch" or if the user has pre-confirmed,
 *	we should not obtain the confirmation and just return that
 *	the user has confirmed.
 */
void
confirm(char *message)
{	FILE *ttyi, *ttyo;
	char ansbuf[ MAX_LINE ];

	/* if user pre-confirmed, we don't have to ask	*/
	if (opt_yes || opt_notouch)
		return;

	ttyo = fopen("/dev/tty", "w");
	ttyi = fopen("/dev/tty", "r");
	if (ttyi == NULL || ttyo == NULL)
		exit(ERR_OTHER);

	/* explain the problem and prompt for confirmation	*/
	fprintf(ttyo, message);
	fprintf(ttyo, gettext(WARN_proceed));

	/* if the user doesn't kill us, we can continue		*/
	(void) fgets(ansbuf, sizeof (ansbuf), ttyi);

	/* close the files and return				*/
	(void) fclose(ttyi);
	(void) fclose(ttyo);
}

void
nomem(char *reason)
{
	fprintf(stderr, gettext(ERR_nomem), reason);
	exit(ERR_OTHER);
}

/*
 * routine:
 *	findfiles
 *
 * purpose:
 *	to locate our baseline and rules files
 *
 * parameters:
 *	none
 *
 * returns:
 *	error mask
 *	settings of file_base and file_rules
 *
 * side-effects:
 *	in order to keep multiple filesyncs from running in parallel
 *	we put an advisory lock on the baseline file.  If the baseline
 *	file does not exist we create one.  The unlocking (and deletion
 *	of extraneous baselines) is handled in cleanup.
 */
static errmask_t
findfiles(void)		/* find rule and baseline files	*/
{ 	char *s, *where;
	char namebuf[MAX_PATH];
	int ret;
	errmask_t errs = 0;

	/* figure out where the files should be located	*/
	s = getenv("FILESYNC");
	where = (s && *s) ? expand(s) : expand(DFLT_PRFX);

	/* see if we got a viable name		*/
	if (where == 0) {
		fprintf(stderr, gettext(ERR_nofsync));
		return (ERR_FILES);
	}

	/* try to form the name of the rules file */
	strcpy(namebuf, where);
	strcat(namebuf, SUFX_RULES);
	s = strdup(namebuf);
	errs = check_access(namebuf, &new_rules);

	/* if we cannot find a proper rules file, look in the old place */
	if (new_rules && errs == 0) {
		strcpy(namebuf, where);
		strcat(namebuf, SUFX_OLD);
		file_rules = strdup(namebuf);
		errs = check_access(namebuf, &new_rules);

		/* if we couldn't find that either, go with new name	*/
		if (new_rules && errs == 0)
			file_rules = s;
	} else
		file_rules = s;

	/* try to form the name of the baseline file */
	strcpy(namebuf, where);
	strcat(namebuf, SUFX_BASE);
	file_base = strdup(namebuf);
	errs |= check_access(namebuf, &new_baseline);

	if (opt_debug & DBG_FILES) {
		fprintf(stderr, "FILE: %s rules file: %s\n",
			new_rules ? "new" : "existing", file_rules);

		fprintf(stderr, "FILE: %s base file:  %s\n",
			new_baseline ? "new" : "existing", file_base);
	}

	/*
	 * in order to lock out other filesync programs we need some
	 * file we can lock.  We do an advisory lock on the baseline
	 * file.  If no baseline file exists, we create an empty one.
	 */
	if (new_baseline)
		lockfd = creat(file_base, 0666);
	else
		lockfd = open(file_base, O_RDWR);

	if (lockfd < 0) {
		fprintf(stderr, new_baseline ? ERR_creat : ERR_open,
			TXT_base, file_base);
		errs |= ERR_FILES;
	} else {
		ret = lockf(lockfd, F_TLOCK, 0L);
		if (ret < 0) {
			fprintf(stderr, ERR_lock, TXT_base, file_base);
			errs |= ERR_FILES;
		} else if (opt_debug & DBG_FILES)
			fprintf(stderr, "FILE: locking baseline file %s\n",
				file_base);
	}

	return (errs);
}

/*
 * routine:
 *	cleanup
 *
 * purpose:
 *	to clean up temporary files and locking prior to exit
 *
 * paremeters:
 *	error mask
 *
 * returns:
 *	void
 *
 * notes:
 *	if there are no errors, the baseline file is assumed to be good.
 *	Otherwise, if we created a temporary baseline file (just for
 *	locking) we will delete it.
 */
static void
cleanup(errmask_t errmask)
{
	/* unlock the baseline file	*/
	if (opt_debug & DBG_FILES)
		fprintf(stderr, "FILE: unlock baseline file %s\n", file_base);
	(void) lockf(lockfd, F_ULOCK, 0);

	/* see if we need to delete a temporary copy	*/
	if (errmask && new_baseline) {
		if (opt_debug & DBG_FILES)
			fprintf(stderr, "FILE: unlink temp baseline file %s\n",
				file_base);
		(void) unlink(file_base);
	}
}

/*
 * routine:
 *	check_access
 *
 * purpose:
 *	to determine whether or not we can access an existing file
 *	or create a new one
 *
 * parameters:
 *	name of file (in a clobberable buffer)
 *	pointer to new file flag
 *
 * returns:
 *	error mask
 *	setting of the new file flag
 *
 * note:
 *	it is kind of a kluge that this routine clobbers the name,
 *	but it is only called from one place, it needs a modified
 *	copy of the name, and the one caller doesn't mind.
 */
static errmask_t
check_access(char *name, int *newflag)
{	char *s;

	/* start out by asking for what we want		*/
	if (access(name, R_OK|W_OK) == 0) {
		*newflag = 0;
		return (0);
	}

	/* if the problem is isn't non-existence, lose	*/
	if (errno != ENOENT) {
		*newflag = 0;
		fprintf(stderr, gettext(ERR_rdwri), name);
		return (ERR_FILES);
	}

	/*
	 * the file doesn't exist, so there is still hope if we can
	 * write in the directory that should contain the file
	 */
	*newflag = 1;

	/* truncate the file name to its containing directory */
	for (s = name; s[1]; s++);
	while (s > name && *s != '/')
		s--;
	if (s > name)
		*s = 0;
	else if (*s == '/')
		s[1] = 0;
	else
		name = ".";

	/* then see if we have write access to the directory	*/
	if (access(name, W_OK) == 0)
		return (0);

	fprintf(stderr, gettext(ERR_dirwac), name);
	return (ERR_FILES);
}

/*
 * routine:
 *	whoami
 *
 * purpose:
 *	to figure out who I am and what the default modes/ownership
 *	is on files that I create.
 */
static void
whoami()
{
	my_uid = geteuid();
	my_gid = getegid();
	my_umask = umask(0);

	if (opt_debug & DBG_MISC)
		fprintf(stderr, "MISC: my_uid=%u, my_gid=%u, my_umask=%03o\n",
			my_uid, my_gid, my_umask);
}