xref: /titanic_41/usr/src/cmd/filesync/eval.c (revision 40db2e2b777b79f3dd0d6d9629593a07f86b9c0a)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 1995-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * module:
 *	eval.c
 *
 * purpose:
 *	routines to ascertain the current status of all of the files
 *	described by a set of rules.  Some of the routines that update
 *	file status information are also called later (during reconcilation)
 *	to reflect the changes that have been made to files.
 *
 * contents:
 *	evaluate	top level - evaluate one side of one base
 *	add_file_arg	(static) add a file to the list of files to evaluate
 *	eval_file	(static) stat a specific file, recurse on directories
 *	walker		(static) node visitor for recursive descent
 *	note_info	update a file_info structure from a stat structure
 *	do_update	(static) update one file_info structure from another
 *	update_info	update the baseline file_info from the prevailng side
 *	fakedata	(static) make it look like one side hasn't changed
 *	check_inum	(static) sanity check to detect wrong-dir errors
 *	add_glob	(static) expand a wildcard in an include rule
 *	add_run		(static) run a program to generate an include list
 *
 * notes:
 *	pay careful attention to the use of the LISTED and EVALUATE
 *	flags in each file description structure.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <unistd.h>
#include <string.h>
#include <glob.h>
#include <ftw.h>
#include <sys/mkdev.h>
#include <errno.h>

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

/*
 * routines:
 */
static errmask_t eval_file(struct base *, struct file *);
static errmask_t add_file_arg(struct base *, char *);
static int walker(const char *, const struct stat *, int, struct FTW *);
static errmask_t add_glob(struct base *, char *);
static errmask_t add_run(struct base *, char *);
static void check_inum(struct file *, int);
static void fakedata(struct file *, int);

/*
 * globals
 */
static bool_t usingsrc;	/* this pass is on the source side		*/
static int walk_errs;	/* errors found in tree walk			*/
static struct file *cur_dir;	/* base directory for this pass		*/
static struct base *cur_base;	/* base pointer for this pass		*/

/*
 * routine:
 *	evaluate
 *
 * purpose:
 *	to build up a baseline description for all of the files
 *	under one side of one base pair (as specified by the rules
 *	for that base pair).
 *
 * parameters:
 *	pointer to the base to be evaluated
 *	source/destination indication
 *	are we restricted to new rules
 *
 * returns:
 *	error mask
 *
 * notes:
 *	we evaluate source and destination separately, and
 *	reinterpret the include rules on each side (since there
 *	may be wild cards and programs that must be evaluated
 *	in a specific directory context).  Similarly the ignore
 *	rules must be interpreted anew for each base.
 */
errmask_t
evaluate(struct base *bp, side_t srcdst, bool_t newrules)
{	errmask_t errs = 0;
	char *dir;
	struct rule *rp;
	struct file *fp;

	/* see if this base is still relevant		*/
	if ((bp->b_flags & F_LISTED) == 0)
		return (0);

	/* figure out what this pass is all about	*/
	usingsrc = (srcdst == OPT_SRC);

	/*
	 * the ignore engine maintains considerable per-base-directory
	 * state, and so must be reset at the start of a new tree.
	 */
	ignore_reset();

	/* all evaluation must happen from the appropriate directory */
	dir = usingsrc ? bp->b_src_name : bp->b_dst_name;
	if (chdir(dir) < 0) {
		fprintf(stderr, gettext(ERR_chdir), dir);

		/*
		 * if we have -n -o we are actually willing to
		 * pretend that nothing has changed on the missing
		 * side.  This is actually useful on a disconnected
		 * notebook to ask what has been changed so far.
		 */
		if (opt_onesided == (usingsrc ? OPT_DST : OPT_SRC)) {
			for (fp = bp->b_files; fp; fp = fp->f_next)
				fakedata(fp, srcdst);

			if (opt_debug & DBG_EVAL)
				fprintf(stderr, "EVAL: FAKE DATA %s dir=%s\n",
					usingsrc ? "SRC" : "DST", dir);
			return (0);
		} else
			return (ERR_NOBASE);
	}

	if (opt_debug & DBG_EVAL)
		fprintf(stderr, "EVAL: base=%d, %s dir=%s\n",
			bp->b_ident, usingsrc ? "SRC" : "DST", dir);

	/* assemble the include list			*/
	for (rp = bp->b_includes; rp; rp = rp->r_next) {

		/* see if we are skipping old rules	*/
		if (newrules && ((rp->r_flags & R_NEW) == 0))
			continue;

		if (rp->r_flags & R_PROGRAM)
			errs |= add_run(bp, rp->r_file);
		else if (rp->r_flags & R_WILD)
			errs |= add_glob(bp, rp->r_file);
		else
			errs |= add_file_arg(bp, rp->r_file);
	}

	/* assemble the base-specific exclude list		*/
	for (rp = bp->b_excludes; rp; rp = rp->r_next)
		if (rp->r_flags & R_PROGRAM)
			ignore_pgm(rp->r_file);
		else if (rp->r_flags & R_WILD)
			ignore_expr(rp->r_file);
		else
			ignore_file(rp->r_file);

	/* add in the global excludes				*/
	for (rp = omnibase.b_excludes; rp; rp = rp->r_next)
		if (rp->r_flags & R_WILD)
			ignore_expr(rp->r_file);
		else
			ignore_file(rp->r_file);

	/*
	 * because of restriction lists and new-rules, the baseline
	 * may contain many more files than we are actually supposed
	 * to look at during the impending evaluation/analysis phases
	 *
	 * when LIST arguments are encountered within a rule, we turn
	 * on the LISTED flag for the associated files.  We only evaluate
	 * files that have the LISTED flag.  We turn the LISTED flag off
	 * after evaluating them because just because a file was enumerated
	 * in the source doesn't mean that will necessarily be enumerated
	 * in the destination.
	 */
	for (fp = bp->b_files; fp; fp = fp->f_next)
		if (fp->f_flags & F_LISTED) {
			errs |= eval_file(bp, fp);
			fp->f_flags &= ~F_LISTED;
		}

	/* note that this base has been evaluated	*/
	bp->b_flags |= F_EVALUATE;

	return (errs);
}

/*
 * routine:
 *	add_file_arg
 *
 * purpose:
 *	to create file node(s) under a specified base for an explictly
 *	included file.
 *
 * parameters:
 *	pointer to associated base
 *	name of the file
 *
 * returns:
 *	error mask
 *
 * notes:
 *	the trick is that an include LIST argument need not be a file
 *	in the base directory, but may be a path passing through
 *	several intermediate directories.  If this is the case we
 *	need to ensure that all of those directories are added to
 *	the tree SPARSELY since it is not intended that they be
 *	expanded during the course of evaluation.
 *
 *	we ignore arguments that end in .. because they have the
 *	potential to walk out of the base tree, because it can
 *	result in different names for a single file, and because
 *	should never be necessary to specify files that way.
 */
static errmask_t
add_file_arg(struct base *bp, char *path)
{	int i;
	errmask_t errs = 0;
	struct file *dp = 0;
	struct file *fp;
	char *s, *p;
	char name[ MAX_NAME ];

	/*
	 * see if someone is trying to feed us a ..
	 */
	if (strcmp(path, "..") == 0 || prefix(path, "../") ||
	    suffix(path, "/..") || contains(path, "/../")) {
		fprintf(stderr, gettext(WARN_ignore), path);
		return (ERR_MISSING);
	}

	/*
	 * strip off any trailing "/." or "/"
	 *	since noone will miss these, it is safe to actually
	 *	take them off the name.  When we fall out of this
	 *	loop, s will point where the null belongs.  We don't
	 *	actually null the end of string yet because we want
	 *	to leave it pristine for error messages.
	 */
	for (s = path; *s; s++);
	while (s > path) {
		if (s[-1] == '/') {
			s--;
			continue;
		}
		if (s[-1] == '.' && s > &path[1] && s[-2] == '/') {
			s -= 2;
			continue;
		}
		break;
	}

	/*
	 * skip over leading "/" and "./" (but not over a lone ".")
	 */
	for (p = path; p < s; ) {
		if (*p == '/') {
			p++;
			continue;
		}
		if (*p == '.' && s > &p[1] && p[1] == '/') {
			p += 2;
			continue;
		}
		break;
	}

	/*
	 * if there is nothing left, we're miffed, but done
	 */
	if (p >= s) {
		fprintf(stderr, gettext(WARN_ignore), path);
		return (ERR_MISSING);
	} else {
		/*
		 * this is actually storing a null into the argument,
		 * but it is OK to do this because the stuff we are
		 * truncating really is garbage that noone will ever
		 * want to see.
		 */
		*s = 0;
		path = p;
	}

	/*
	 * see if there are any restrictions that would force
	 * us to ignore this argument
	 */
	if (check_restr(bp, path) == 0)
		return (0);

	while (*path) {
		/* lex off the next name component	*/
		for (i = 0; path[i] && path[i] != '/'; i++)
			name[i] = path[i];
		name[i] = 0;

		/* add it into the database		*/
		fp = (dp == 0)  ? add_file_to_base(bp, name)
				: add_file_to_dir(dp, name);

		/* see if this was an intermediate directory	*/
		if (path[i] == '/') {
			fp->f_flags |= F_LISTED | F_SPARSE;
			path += i+1;
		} else {
			fp->f_flags |= F_LISTED;
			path += i;
		}

		dp = fp;
	}

	return (errs);
}

/*
 * routine:
 *	eval_file
 *
 * purpose:
 *	to evaluate one named file under a particular directory
 *
 * parameters:
 *	pointer to base structure
 *	pointer to file structure
 *
 * returns:
 *	error mask
 *	filled in evaluations in the baseline
 *
 * note:
 *	due to new rules and other restrictions we may not be expected
 *	to evaluate the entire tree.  We should only be called on files
 *	that are LISTed, and we should only invoke ourselves recursively
 *	on such files.
 */
static errmask_t
eval_file(struct base *bp, struct file *fp)
{	errmask_t errs = 0;
	int rc;
	char *name;
	struct file *cp;
	struct stat statb;

	if (opt_debug & DBG_EVAL)
		fprintf(stderr, "EVAL: FILE, flags=%s, name=%s\n",
			showflags(fileflags, fp->f_flags), fp->f_name);

	/* stat the file and fill in the file structure information	*/
	name = get_name(fp);

#ifdef 	DBG_ERRORS
	/* see if we should simulated a stat error on this file	*/
	if (opt_errors && (errno = dbg_chk_error(name, usingsrc ? 's' : 'S')))
		rc = -1;
	else
#endif
	rc = lstat(name, &statb);

	if (rc < 0) {
		if (opt_debug & DBG_EVAL)
			fprintf(stderr, "EVAL: FAIL lstat, errno=%d\n", errno);
		switch (errno) {
		    case EACCES:
			fp->f_flags |= F_STAT_ERROR;
			return (ERR_PERM);
		    case EOVERFLOW:
			fp->f_flags |= F_STAT_ERROR;
			return (ERR_UNRESOLVED);
		    default:
			return (ERR_MISSING);
		}
	}

	/* record the information we've just gained			*/
	note_info(fp, &statb, usingsrc ? OPT_SRC : OPT_DST);

	/*
	 * checking for ACLs is expensive, so we only do it if we
	 * have been asked to, or if we have reason to believe that
	 * the file has an ACL
	 */
	if (opt_acls || fp->f_info[OPT_BASE].f_numacls)
		(void) get_acls(name,
				&fp->f_info[usingsrc ? OPT_SRC : OPT_DST]);


	/* note that this file has been evaluated			*/
	fp->f_flags |= F_EVALUATE;

	/* if it is not a directory, a simple stat will suffice	*/
	if ((statb.st_mode & S_IFMT) != S_IFDIR)
		return (0);

	/*
	 * as a sanity check, we look for changes in the I-node
	 * numbers associated with LISTed directories ... on the
	 * assumption that these are high-enough up on the tree
	 * that they aren't likely to change, and so a change
	 * might indicate trouble.
	 */
	if (fp->f_flags & F_LISTED)
		check_inum(fp, usingsrc);

	/*
	 * sparse directories are on the path between a base and
	 * a listed directory.  As such, we don't walk these
	 * directories.  Rather, we just enumerate the LISTed
	 * files.
	 */
	if (fp->f_flags & F_SPARSE) {
		push_name(fp->f_name);

		/* this directory isn't supposed to be fully walked	*/
		for (cp = fp->f_files; cp; cp = cp->f_next)
			if (cp->f_flags & F_LISTED) {
				errs |= eval_file(bp, cp);
				cp->f_flags &= ~F_LISTED;
			}
		pop_name();
	} else {
		/* fully walk the tree beneath this directory		*/
		walk_errs = 0;
		cur_base = bp;
		cur_dir = fp;
		nftw(get_name(fp), &walker, MAX_DEPTH, FTW_PHYS|FTW_MOUNT);
		errs |= walk_errs;
	}

	return (errs);
}

/*
 * routine:
 *	walker
 *
 * purpose:
 *	node visitor for recursive directory enumeration
 *
 * parameters:
 *	name of file
 *	pointer to stat buffer for file
 *	file type
 *	FTW structure (base name offset, walk-depth)
 *
 * returns:
 *	0 	continue
 *	-1	stop
 *
 * notes:
 *	Ignoring files is easy, but ignoring directories is harder.
 *	Ideally we would just decline to walk the trees beneath
 *	ignored directories, but ftw doesn't allow the walker to
 *	tell it to "don't enter this directory, but continue".
 *
 *	Instead, we have to set a global to tell us to ignore
 *	everything under that tree.  The variable ignore_level
 *	is set to a level, below which, everything should be
 *	ignored.  Once the enumeration rises above that level
 *	again, we clear it.
 */
static int
walker(const char *name, const struct stat *sp, int type,
		struct FTW *ftwx)
{	const char *path;
	struct file *fp;
	int level;
	int which;
	bool_t restr;
	static struct file *dirstack[ MAX_DEPTH + 1 ];
	static int ignore_level = 0;

	path = &name[ftwx->base];
	level = ftwx->level;
	which = usingsrc ? OPT_SRC : OPT_DST;

	/*
	 * see if we are ignoring all files in this sub-tree
	 */
	if (ignore_level > 0 && level >= ignore_level) {
		if (opt_debug & DBG_EVAL)
			fprintf(stderr, "EVAL: SKIP file=%s\n", name);
		return (0);
	} else
		ignore_level = 0;	/* we're through ignoring	*/

#ifdef 	DBG_ERRORS
	/* see if we should simulated a stat error on this file	*/
	if (opt_errors && dbg_chk_error(name, usingsrc ? 'n' : 'N'))
		type = FTW_NS;
#endif

	switch (type) {
	case FTW_F:	/* file 		*/
	case FTW_SL:	/* symbolic link	*/
		/*
		 * filter out files of inappropriate types
		 */
		switch (sp->st_mode & S_IFMT) {
			default:	/* anything else we ignore	*/
				return (0);

			case S_IFCHR:
			case S_IFBLK:
			case S_IFREG:
			case S_IFLNK:
				if (opt_debug & DBG_EVAL)
					fprintf(stderr,
						"EVAL: WALK lvl=%d, file=%s\n",
						level, path);

				/* see if we were told to ignore this one */
				if (ignore_check(path))
					return (0);

				fp = add_file_to_dir(dirstack[level-1], path);
				note_info(fp, sp, which);

				/* note that this file has been evaluated */
				fp->f_flags |= F_EVALUATE;

				/* see if we should check ACLs		*/
				if ((sp->st_mode & S_IFMT) == S_IFLNK)
					return (0);

				if (fp->f_info[OPT_BASE].f_numacls || opt_acls)
					(void) get_acls(name,
							&fp->f_info[which]);

				return (0);
		}

	case FTW_D:	/* enter directory 		*/
		if (opt_debug & DBG_EVAL)
			fprintf(stderr, "EVAL: WALK lvl=%d, dir=%s\n",
				level, name);

		/*
		 * if we have been told to ignore this directory, we should
		 * ignore all files under it.  Similarly, if we are outside
		 * of our restrictions, we should ignore the entire subtree
		 */
		restr = check_restr(cur_base, name);
		if (restr == FALSE || ignore_check(path)) {
			ignore_level = level + 1;
			return (0);
		}

		fp = (level == 0) ?  cur_dir :
		    add_file_to_dir(dirstack[level-1], path);

		note_info(fp, sp, which);

		/* see if we should be checking ACLs	*/
		if (opt_acls || fp->f_info[OPT_BASE].f_numacls)
			(void) get_acls(name, &fp->f_info[which]);

		/* note that this file has been evaluated */
		fp->f_flags |= F_EVALUATE;

		/* note the parent of the children to come	*/
		dirstack[ level ] = fp;

		/*
		 * PROBLEM: given the information that nftw provides us with,
		 *	    how do we know that we have confirmed the fact
		 *	    that a file no longer exists.  Or to rephrase
		 *	    this in filesync terms, how do we know when to
		 *	    set the EVALUATE flag for a file we didn't find.
		 *
		 * if we are going to fully scan this directory (we
		 * are completely within our restrictions) then we
		 * will be confirming the non-existance of files that
		 * used to be here.  Thus any file that was in the
		 * base line under this directory should be considered
		 * to have been evaluated (whether we found it or not).
		 *
		 * if, however, we are only willing to scan selected
		 * files (due to restrictions), or the file was not
		 * in the baseline, then we should not assume that this
		 * pass will evaluate it.
		 */
		if (restr == TRUE)
			for (fp = fp->f_files; fp; fp = fp->f_next) {
				if ((fp->f_flags & F_IN_BASELINE) == 0)
					continue;
				fp->f_flags |= F_EVALUATE;
			}

		return (0);

	case FTW_DP:	/* end of directory	*/
		dirstack[ level ] = 0;
		break;

	case FTW_DNR:	/* unreadable directory	*/
		walk_errs |= ERR_PERM;
		/* FALLTHROUGH	*/
	case FTW_NS:	/* unstatable file	*/
		if (opt_debug & DBG_EVAL)
			fprintf(stderr, "EVAL: walker can't stat/read %s\n",
				name);
		fp = (level == 0) ?  cur_dir :
			add_file_to_dir(dirstack[level-1], path);
		fp->f_flags |= F_STAT_ERROR;
		walk_errs |= ERR_UNRESOLVED;
		break;
	}

	return (0);
}

/*
 * routine:
 *	note_info
 *
 * purpose:
 * 	to record information about a file in its file node
 *
 * parameters
 *	file node pointer
 *	stat buffer
 *	which file info structure to fill in (0-2)
 *
 * returns
 *	void
 */
void
note_info(struct file *fp, const struct stat *sp, side_t which)
{	struct fileinfo *ip;
	static int flags[3] = { F_IN_BASELINE, F_IN_SOURCE, F_IN_DEST };

	ip = &fp->f_info[ which ];

	ip->f_ino	= sp->st_ino;
	ip->f_d_maj	= major(sp->st_dev);
	ip->f_d_min	= minor(sp->st_dev);
	ip->f_type	= sp->st_mode & S_IFMT;
	ip->f_size	= sp->st_size;
	ip->f_mode	= sp->st_mode & S_IAMB;
	ip->f_uid	= sp->st_uid;
	ip->f_gid	= sp->st_gid;
	ip->f_modtime	= sp->st_mtim.tv_sec;
	ip->f_modns	= sp->st_mtim.tv_nsec;
	ip->f_nlink	= sp->st_nlink;
	ip->f_rd_maj	= major(sp->st_rdev);
	ip->f_rd_min	= minor(sp->st_rdev);

	/* indicate where this file has been found	*/
	fp->f_flags |= flags[which];

	if (opt_debug & DBG_STAT)
		fprintf(stderr,
			"STAT: list=%d, file=%s, mod=%08lx.%08lx, nacl=%d\n",
			which, fp->f_name, ip->f_modtime, ip->f_modns,
			ip->f_numacls);
}

/*
 * routine:
 *	do_update
 *
 * purpose:
 * 	to copy information from one side into the baseline in order
 *	to reflect the effects of recent reconciliation actions
 *
 * parameters
 *	fileinfo structure to be updated
 *	fileinfo structure to be updated from
 *
 * returns
 *	void
 *
 * note:
 *	we play fast and loose with the copying of acl chains
 *	here, but noone is going to free or reuse any of this
 * 	memory anyway.  None the less, I do feel embarassed.
 */
static void
do_update(struct fileinfo *np, struct fileinfo *ip)
{
	/* get most of the fields from the designated "right" copy */
	np->f_type	= ip->f_type;
	np->f_size	= ip->f_size;
	np->f_mode	= ip->f_mode;
	np->f_uid	= ip->f_uid;
	np->f_gid	= ip->f_gid;
	np->f_rd_maj	= ip->f_rd_maj;
	np->f_rd_min	= ip->f_rd_min;

	/* see if facls have to be propagated	*/
	np->f_numacls = ip->f_numacls;
	np->f_acls = ip->f_acls;
}

/*
 * routine:
 *	update_info
 *
 * purpose:
 * 	to update the baseline to reflect recent reconcliations
 *
 * parameters
 *	file node pointer
 *	which file info structure to trust (1/2)
 *
 * returns
 *	void
 *
 * note:
 *	after we update this I-node we run down the entire
 *	change list looking for links and update them too.
 *	This is to ensure that when subsequent links get
 *	reconciled, they are already found to be up-to-date.
 */
void
update_info(struct file *fp, side_t which)
{
	/* first update the specified fileinfo structure	*/
	do_update(&fp->f_info[ OPT_BASE ], &fp->f_info[ which ]);

	if (opt_debug & DBG_STAT)
		fprintf(stderr,
			"STAT: UPDATE from=%d, file=%s, mod=%08lx.%08lx\n",
			which, fp->f_name, fp->f_info[ which ].f_modtime,
			fp->f_info[ which ].f_modns);
}

/*
 * routine:
 *	fakedata
 *
 * purpose:
 *	to populate a tree we cannot analyze with information from the baseline
 *
 * parameters:
 *	file to be faked
 *	which side to fake
 *
 * notes:
 *	We would never use this for real reconciliation, but it is useful
 *	if a disconnected notebook user wants to find out what has been
 *	changed so far.  We only do this if we are notouch and oneway.
 */
static void
fakedata(struct file *fp, int which)
{	struct file *lp;

	/* pretend we actually found the file			*/
	fp->f_flags |= (which == OPT_SRC) ? F_IN_SOURCE : F_IN_DEST;

	/* update the specified side from the baseline		*/
	do_update(&fp->f_info[ which ], &fp->f_info[ OPT_BASE ]);
	fp->f_info[which].f_nlink = (which == OPT_SRC) ? fp->f_s_nlink :
							fp->f_d_nlink;
	fp->f_info[which].f_modtime = (which == OPT_SRC) ? fp->f_s_modtime :
							fp->f_d_modtime;

	for (lp = fp->f_files; lp; lp = lp->f_next)
		fakedata(lp, which);
}

/*
 * routine:
 *	check_inum
 *
 * purpose:
 *	sanity check inode #s on directories that are unlikely to change
 *
 * parameters:
 *	pointer to file node
 *	are we using the source
 *
 * note:
 *	the purpose of this sanity check is to catch a case where we
 *	have somehow been pointed at a directory that is not the one
 *	we expected to be reconciling against.  It could happen if a
 *	variable wasn't properly set, or if we were in a new domain
 *	where an old path no longer worked.  This could result in
 *	bazillions of inappropriate propagations and deletions.
 */
void
check_inum(struct file *fp, int src)
{	struct fileinfo *ip;

	/*
	 * we validate the inode number and the major device numbers ... minor
	 * device numbers for NFS devices are arbitrary
	 */
	if (src) {
		ip = &fp->f_info[ OPT_SRC ];
		if (ip->f_ino == fp->f_s_inum && ip->f_d_maj == fp->f_s_maj)
			return;

		/* if file was newly created/deleted, this isn't warnable */
		if (fp->f_s_inum == 0 || ip->f_ino == 0)
			return;

		if (opt_verbose)
			fprintf(stdout, V_change, fp->f_name, TXT_src,
				fp->f_s_maj, fp->f_s_min, fp->f_s_inum,
				ip->f_d_maj, ip->f_d_min, ip->f_ino);
	} else {
		ip = &fp->f_info[ OPT_DST ];
		if (ip->f_ino == fp->f_d_inum && ip->f_d_maj == fp->f_d_maj)
			return;

		/* if file was newly created/deleted, this isn't warnable */
		if (fp->f_d_inum == 0 || ip->f_ino == 0)
			return;

		if (opt_verbose)
			fprintf(stdout, V_change, fp->f_name, TXT_dst,
				fp->f_d_maj, fp->f_d_min, fp->f_d_inum,
				ip->f_d_maj, ip->f_d_min, ip->f_ino);
	}

	/* note that something has changed	*/
	inum_changes++;
}

/*
 * routine:
 *	add_glob
 *
 * purpose:
 *	to evaluate a wild-carded expression into names, and add them
 *	to the evaluation list.
 *
 * parameters:
 *	base
 *	expression
 *
 * returns:
 * 	error mask
 *
 * notes:
 *	we don't want to allow any patterns to expand to a . because
 *	that could result in re-evaluation of a tree under a different
 *	name.  The real thing we are worried about here is ".*" which
 *	is meant to pick up . files, but shouldn't pick up . and ..
 */
static errmask_t
add_glob(struct base *bp, char *expr)
{	int i;
	errmask_t errs = 0;
#ifndef BROKEN_GLOB
	glob_t gt;
	char *s;

	/* expand the regular expression	*/
	i = glob(expr, GLOB_NOSORT, 0, &gt);
	if (i == GLOB_NOMATCH)
		return (ERR_MISSING);
	if (i) {
		/* this shouldn't happen, so it's cryptic message time	*/
		fprintf(stderr, "EVAL: add_glob globfail expr=%s, ret=%d\n",
				expr, i);
		return (ERR_OTHER);
	}

	for (i = 0; i < gt.gl_pathc; i++) {
		/* make sure we don't let anything expand to a . */
		s = basename(gt.gl_pathv[i]);
		if (strcmp(s, ".") == 0) {
			fprintf(stderr, gettext(WARN_ignore), gt.gl_pathv[i]);
			errs |= ERR_MISSING;
			continue;
		}

		errs |= add_file_arg(bp, gt.gl_pathv[i]);
	}

	globfree(&gt);
#else
	/*
	 * in 2.4 the glob function was completely broken.  The
	 * easiest way to get around this problem is to just ask
	 * the shell to do the work for us.  This is much slower
	 * but produces virtually identical results.  Given that
	 * the 2.4 version is internal use only, I probably won't
	 * worry about the performance difference (less than 2
	 * seconds for a typical filesync command, and no hit
	 * at all if they don't use regular expressions in
	 * their LIST rules).
	 */
	char cmdbuf[MAX_LINE];

	sprintf(cmdbuf, "ls -d %s 2> /dev/null", expr);
	errs |= add_run(bp, cmdbuf);
#endif

	return (errs);
}


/*
 * routine:
 *	add_run
 *
 * purpose:
 *	to run a command and capture the names it outputs in the
 *	evaluation list.
 *
 * parameters
 *	base
 *	command
 *
 * returns:
 *	error mask
 */
static errmask_t
add_run(struct base *bp, char *cmd)
{	char *s, *p;
	FILE *fp;
	char inbuf[ MAX_LINE ];
	errmask_t errs = 0;
	int added = 0;

	if (opt_debug & DBG_EVAL)
		fprintf(stderr, "EVAL: RUN %s\n", cmd);

	/* run the command and collect its ouput	*/
	fp = popen(cmd, "r");
	if (fp == NULL) {
		fprintf(stderr, gettext(ERR_badrun), cmd);
		return (ERR_OTHER);
	}

	while (fgets(inbuf, sizeof (inbuf), fp) != 0) {
		/* strip off any trailing newline	*/
		for (s = inbuf; *s && *s != '\n'; s++);
		*s = 0;

		/* skip any leading white space		*/
		for (s = inbuf; *s == ' ' || *s == '\t'; s++);

		/* make sure we don't let anything expand to a . */
		p = basename(s);
		if (strcmp(p, ".") == 0) {
			fprintf(stderr, gettext(WARN_ignore), s);
			errs |= ERR_MISSING;
			continue;
		}

		/* add this file to the list		*/
		if (*s) {
			errs |= add_file_arg(bp, s);
			added++;
		}
	}

	pclose(fp);

#ifdef	BROKEN_GLOB
	/*
	 * if we are being used to simulate libc glob, and we didn't
	 * return anything, we should probably assume that the regex
	 * was unable to match anything
	 */
	if (added == 0)
		errs |= ERR_MISSING;
#endif
	return (errs);
}