xref: /titanic_51/usr/src/cmd/filesync/recon.c (revision ee5416c9d7e449233197d5d20bc6b81e4ff091b2)

/*
 * 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 (c) 1995 Sun Microsystems, Inc.  All Rights Reserved
 *
 * module:
 *	recon.c
 *
 * purpose:
 *	process the reconciliation list, figure out exactly what the
 *	changes were, and what we should do about them.
 *
 * contents:
 *	reconcile ... (top level) process the reconciliation list
 *	samedata .... (static) do two files have the same contents
 *	samestuff ... (static) do two files have the same ownership/protection
 *	samecompare . (static) actually read and compare the contents
 *	samelink .... (static) do two symlinks have the same contents
 *	truncated ... (static) was one of the two copies truncted
 *	older ....... (static) which copy is older
 *	newer ....... (static) which copy is newer
 *	full_name ... generate a full path name for a file
 *
 * notes:
 *	If you only study one routine in this whole program, reconcile
 *	is that routine.  Everything else is just book keeping.
 *
 *	things were put onto the reconciliation list because analyze
 *	thought that they might have changed ... but up until now
 *	nobody has figured out what the changes really were, or even
 *	if there really were any changes.
 *
 *	queue_file has ordered the reconciliation list with directory
 *	creations first (depth ordered) and deletions last (inversely
 *	depth ordered).  all other changes have been ordered by mod time.
 */
#ident	"%W%	%E% SMI"

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

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

/*
 * local routines to figure out how the files really differ
 */
static bool_t samedata(struct file *);
static bool_t samestuff(struct file *);
static bool_t samecompare(struct file *);
static bool_t truncated(struct file *);
static bool_t samelink();
static side_t newer(struct file *);
static side_t older(struct file *);

/*
 * globals
 */
char	*srcname;	/* file we are emulating		*/
char	*dstname;	/* file we are updating			*/

/*
 * routine:
 *	reconcile
 *
 * purpose:
 *	to perform the reconciliation action associated with a file
 *
 * parameters:
 *	file pointer
 *
 * returns:
 *	built up error mask
 *	updated statistics
 *
 * notes:
 *	The switch statement handles the obvious stuff.
 *	The TRUE side of the samedata test handles minor differences.
 *	The interesting stuff is in the FALSE side of the samedata test.
 *
 *	The desparation heuristics (in the diffmask&CONTENTS test) are
 *	not rigorously correct ... but they always try do the right thing
 *	with data, and only lose mode/ownership changes in relatively
 *	pathological cases.  But I claim that the benefits outweigh the
 *	risks, and most users will be pleased with the resulting decisions.
 *
 *	Another trick is in the deletion cases of the switch.  We
 *	normally won't allow an unlink that conflicts with data
 *	changes.  If there are multiple links to the file, however,
 * 	we can make the changes and do the deletion.
 *
 *	The action routines do_{remove,rename,like,copy} handle all
 *	of their own statistics and status updating.  This routine
 *	only has to handle its own reconciliation failures (when we
 *	can't decide what to do).
 */
errmask_t
reconcile(struct file *fp)
{	errmask_t errs = 0;
	diffmask_t diffmask;

	if (opt_debug & DBG_RECON)
		fprintf(stderr, "RECO: %s flgs=%s, mtime=%08lx.%08lx\n",
			fp->f_fullname,
			showflags(fileflags, fp->f_flags),
			fp->f_modtime, fp->f_modns);

	/*
	 * form the fully qualified names for both files
	 */
	srcname = full_name(fp, OPT_SRC, OPT_SRC);
	dstname = full_name(fp, OPT_DST, OPT_DST);

	/*
	 * because they are so expensive to read and so troublesome
	 * to set, we try to put off reading ACLs as long as possible.
	 * If we haven't read them yet, we must read them now (so that
	 * samestuff can compare them).
	 */
	if (opt_acls == 0 && fp->f_info[ OPT_BASE ].f_numacls == 0) {
		if (get_acls(srcname, &fp->f_info[ OPT_SRC ]))
			fp->f_srcdiffs |= D_FACLS;
		if (get_acls(dstname, &fp->f_info[ OPT_DST ]))
			fp->f_dstdiffs |= D_FACLS;
	}

	/*
	 * If a rename has been detected, we don't have to figure
	 * it out, since both the rename-to and rename-from files
	 * have already been designated.  When we encounter a rename-to
	 * we should carry it out.  When we encounter a rename-from
	 * we can ignore it, since it should be dealt with as a side
	 * effect of processing the rename-to.
	 */
	if ((fp->f_srcdiffs|fp->f_dstdiffs) & D_RENAME_FROM)
		return (0);

	if ((fp->f_srcdiffs|fp->f_dstdiffs) & D_RENAME_TO) {

		if (opt_verbose)
			fprintf(stdout, gettext(V_renamed),
				fp->f_previous->f_fullname, fp->f_name);

		if (fp->f_srcdiffs & D_RENAME_TO) {
			errs = do_rename(fp, OPT_DST);
			fp->f_srcdiffs &= D_MTIME | D_SIZE;
		} else if (fp->f_dstdiffs & D_RENAME_TO) {
			errs = do_rename(fp, OPT_SRC);
			fp->f_dstdiffs &= D_MTIME | D_SIZE;
		}

		if (errs != ERR_RESOLVABLE)
			goto done;

		/*
		 * if any differences remain, then we may be dealing
		 * with contents changes in addition to a rename
		 */
		if ((fp->f_srcdiffs | fp->f_dstdiffs) == 0)
			goto done;

		/*
		 * fall through to reconcile the data changes
		 */
	}

	/*
	 * pull of the easy cases (non-conflict creations & deletions)
	 */
	switch (fp->f_flags & (F_WHEREFOUND)) {
		case F_IN_BASELINE:	/* only exists in baseline	*/
		case 0:			/* only exists in rules		*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_nomore),
					fp->f_fullname);
			fp->f_flags |= F_REMOVE;	/* fix baseline	*/
			return (0);

		case F_IN_BASELINE|F_IN_SOURCE:	/* deleted from dest	*/
			/*
			 * the basic principle here is that we are willing
			 * to do the deletion if:
			 *	no changes were made on the other side
			 * OR
			 *	we have been told to force in this direction
			 *
			 * we do, however, make an exception for files that
			 * will still have other links.  In this case, the
			 * (changed) data will still be accessable through
			 * another link and so we are willing to do the unlink
			 * inspite of conflicting changes (which may well
			 * have been introduced through another link.
			 *
			 * The jury is still out on this one
			 */
			if (((fp->f_srcdiffs&D_IMPORTANT) == 0) ||
				(opt_force == OPT_DST)		||
				has_other_links(fp, OPT_SRC)) {
				if (opt_verbose)
					fprintf(stdout, gettext(V_deleted),
						fp->f_fullname, "dst");
				errs = do_remove(fp, OPT_SRC);
				goto done;
			}

			/* a deletion combined with changes		*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_delconf),
					fp->f_fullname);

			/* if we are to resolve in favor of source	*/
			if (opt_force == OPT_SRC) {
				errs = do_copy(fp, OPT_DST);
				goto done;
			}

			fp->f_problem = gettext(PROB_del_change);
			goto cant;

		case F_IN_BASELINE|F_IN_DEST:	/* deleted from src	*/
			/* just like previous case, w/sides reversed	*/
			if (((fp->f_dstdiffs&D_IMPORTANT) == 0) ||
				(opt_force == OPT_SRC)		||
				has_other_links(fp, OPT_DST)) {
				if (opt_verbose)
					fprintf(stdout, gettext(V_deleted),
						fp->f_fullname, "src");
				errs = do_remove(fp, OPT_DST);
				goto done;
			}

			/* a deletion combined with changes		*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_delconf),
					fp->f_fullname);

			/* if we are to resolve in favor of destination	*/
			if (opt_force == OPT_DST) {
				errs = do_copy(fp, OPT_SRC);
				goto done;
			}

			fp->f_problem = gettext(PROB_del_change);
			goto cant;

		/*
		 * if something new shows up, and for some reason we cannot
		 * propagate it to the other side, we should suppress the
		 * file from the baseline, so it will show up as a new
		 * creation next time too.
		 */
		case F_IN_SOURCE:		/* created in src	*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_created),
					fp->f_fullname, "src");
			errs = do_copy(fp, OPT_DST);
			goto done;

		case F_IN_DEST:			/* created in dest	*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_created),
					fp->f_fullname, "dst");
			errs = do_copy(fp, OPT_SRC);
			goto done;

		case F_IN_SOURCE|F_IN_DEST:	/* not in baseline	*/
			/*
			 * since we don't have a baseline, we cannot
			 * know which of the two copies should prevail
			 */
			break;

		case F_IN_BASELINE|F_IN_SOURCE|F_IN_DEST:
			/*
			 * we have a baseline where the two copies agreed,
			 * so maybe we can determine that only one of the
			 * two copies have changed ... but before we decide
			 * who should be the winner we should determine
			 * that the two copies are actually different.
			 */
			break;
	}

	/*
	 * if we have fallen out of the case statement, it is because
	 * we have discovered a non-obvious situation where potentially
	 * changed versions of the file exist on both sides.
	 *
	 * if the two copies turn out to be identical, this is simple
	 */
	if (samedata(fp)) {
		if (samestuff(fp)) {
			/* files are identical, just update baseline	*/
			if (opt_verbose)
				fprintf(stdout, gettext(V_unchanged),
					fp->f_fullname);
			update_info(fp, OPT_SRC);
			goto done;
		} else {
			/*
			 * contents agree but ownership/protection does
			 * not agree, so we have to bring these into
			 * agreement.  We can pick a winner if one
			 * side hasn't changed, or if the user has
			 * specified a force flag.
			 */
			if (opt_verbose)
				fprintf(stdout, gettext(V_modes),
					fp->f_fullname);

			if (((fp->f_srcdiffs & D_ADMIN) == 0) ||
					(opt_force == OPT_DST)) {
				errs = do_like(fp, OPT_SRC, TRUE);
				goto done;
			}

			if (((fp->f_dstdiffs & D_ADMIN) == 0) ||
					(opt_force == OPT_SRC)) {
				errs = do_like(fp, OPT_DST, TRUE);
				goto done;
			}
		}
		/* falls down to cant	*/
	} else {
		/*
		 * The two files have different contents, so we have
		 * a potential conflict here.  If we know that only one
		 * side has changed, we go with that side.
		 */
		if (fp->f_dstdiffs == 0 || fp->f_srcdiffs == 0) {
			if (opt_verbose)
				fprintf(stdout, gettext(V_changed),
					fp->f_fullname);
			errs = do_copy(fp, fp->f_srcdiffs ? OPT_DST : OPT_SRC);
			goto done;
		}

		/*
		 * Both sides have changed, so we have a real conflict.
		 */
		if (opt_verbose)
			fprintf(stdout,
				gettext(truncated(fp) ?
						V_trunconf : V_different),
				fp->f_fullname);

		/*
		 * See if the user has given us explicit instructions
		 * on how to resolve conflicts.  We may have been told
		 * to favor the older, the newer, the source, or the
		 * destination ... but the default is to leave the
		 * conflict unresolved.
		 */
		if (opt_force == OPT_OLD) {
			errs = do_copy(fp, newer(fp));
			goto done;
		}

		if (opt_force == OPT_NEW) {
			errs = do_copy(fp, older(fp));
			goto done;
		}

		if (opt_force != 0) {
			errs = do_copy(fp, (opt_force == OPT_SRC) ?
							OPT_DST : OPT_SRC);
			goto done;
		}


		/*
		 * This is our last chance before giving up.
		 *
		 * We know that the files have different contents and
		 * that there were changes on both sides.  The only way
		 * we can safely handle this is if there were pure contents
		 * changes on one side and pure ownership changes on the
		 * other side.  In this case we can propagate the ownership
		 * one way and the contents the other way.
		 *
		 * We decide whether or not this is possible by ANDing
		 * together the changes on the two sides, and seeing
		 * if the changes were all orthogonal (none of the same
		 * things changed on both sides).
		 */
		diffmask = fp->f_srcdiffs & fp->f_dstdiffs;
		if ((diffmask & D_CONTENTS) == 0) {
			/*
			 * if ownership changes were only made on one side
			 * (presumably the side that didn't have data changes)
			 * we can handle them separately.  In this case,
			 * ownership changes must be fixed first, because
			 * the subsequent do_copy will overwrite them.
			 */
			if ((diffmask & D_ADMIN) == 0)
				errs |= do_like(fp, (fp->f_srcdiffs&D_ADMIN) ?
							OPT_DST : OPT_SRC,
						TRUE);

			/*
			 * Now we can deal with the propagation of the data
			 * changes.  Note that any ownership/protection
			 * changes (from the other side) that have not been
			 * propagated yet are about to be lost.  The cases
			 * in which this might happen are all pathological
			 * and the consequences of losing the protection
			 * changes are (IMHO) minor when compared to the
			 * obviously correct data propagation.
			 */
			errs |= do_copy(fp, (fp->f_srcdiffs&D_CONTENTS) ?
						OPT_DST : OPT_SRC);
			goto done;
		}

		/*
		 * there are conflicting changes, nobody has told us how to
		 * resolve conflicts, and we cannot figure out how to merge
		 * the differences.
		 */
		fp->f_problem = gettext(PROB_different);
	}

cant:
	/*
	 * I'm not smart enough to resolve this conflict automatically,
	 * so I have no choice but to bounce it back to the user.
	 */
	fp->f_flags |= F_CONFLICT;
	fp->f_base->b_unresolved++;
	errs |= ERR_UNRESOLVED;

done:
	/*
	 * if we have a conflict and the file is not in the baseline,
	 * then there was never any point at which the two copies were
	 * in agreement, and we want to preserve the conflict for future
	 * resolution.
	 */
	if ((errs&ERR_UNRESOLVED) && (fp->f_flags & F_IN_BASELINE) == 0)
		if (fp->f_files == 0)
			/*
			 * in most cases, this is most easily done by just
			 * excluding the file in question from the baseline
			 */
			fp->f_flags |= F_REMOVE;
		else
			/*
			 * but ... if the file in question is a directory
			 * with children, excluding it from the baseline
			 * would keep all of its children (even those with
			 * no conflicts) out of the baseline as well.  In
			 * This case, it is better to tell a lie and to
			 * manufacture a point of imaginary agreement
			 * in the baseline ... but one that is absurd enough
			 * that we will still see conflicts each time we run.
			 *
			 * recording a type of directory, and everything
			 * else as zero should be absurd enough.
			 */
			fp->f_info[ OPT_BASE ].f_type = S_IFDIR;

	if (opt_debug & DBG_MISC)
		fprintf(stderr, "MISC: %s ERRS=%s\n", fp->f_fullname,
			showflags(errmap, errs));

	return (errs);
}

/*
 * routine:
 *	newer
 *
 * purpose:
 *	determine which of two files is newer
 *
 * parameters:
 *	struct file
 *
 * returns:
 *	side_t (src/dest)
 */
static side_t
newer(struct file *fp)
{
	struct fileinfo *sp, *dp;

	sp = &fp->f_info[OPT_SRC];
	dp = &fp->f_info[OPT_DST];

	if (sp->f_modtime > dp->f_modtime)
		return (OPT_SRC);

	if (sp->f_modtime < dp->f_modtime)
		return (OPT_DST);

	if (sp->f_modns >= dp->f_modns)
		return (OPT_SRC);

	return (OPT_DST);
}

/*
 * routine:
 *	older
 *
 * purpose:
 *	determine which of two files is older
 *
 * parameters:
 *	struct file
 *
 * returns:
 *	side_t (src/dest)
 */
static side_t
older(struct file *fp)
{
	struct fileinfo *sp, *dp;

	sp = &fp->f_info[OPT_SRC];
	dp = &fp->f_info[OPT_DST];

	if (sp->f_modtime < dp->f_modtime)
		return (OPT_SRC);

	if (sp->f_modtime > dp->f_modtime)
		return (OPT_DST);

	if (sp->f_modns <= dp->f_modns)
		return (OPT_SRC);

	return (OPT_DST);
}

/*
 * routine:
 *	samedata
 *
 * purpose:
 *	determine whether or not two files contain the same data
 *
 * parameters:
 *	struct file
 *
 * returns:
 *	bool_t (true/false)
 */
static bool_t
samedata(struct file *fp)
{
	struct fileinfo *sp, *dp;

	sp = &fp->f_info[OPT_SRC];
	dp = &fp->f_info[OPT_DST];

	/* cheap test: types are different		*/
	if (sp->f_type != dp->f_type)
		return (FALSE);

	/* cheap test: directories have same contents	*/
	if (sp->f_type == S_IFDIR)
		return (TRUE);

	/* special files are compared via their maj/min	*/
	if ((sp->f_type == S_IFBLK) || (sp->f_type == S_IFCHR)) {
		if (sp->f_rd_maj != dp->f_rd_maj)
			return (FALSE);
		if (sp->f_rd_min != dp->f_rd_min)
			return (FALSE);
		return (TRUE);
	}

	/* symlinks are the same if their contents are the same	*/
	if (sp->f_type == S_IFLNK)
		return (samelink());

	/* cheap test: sizes are different		*/
	if (fp->f_info[OPT_SRC].f_size != fp->f_info[OPT_DST].f_size)
		return (FALSE);

	/* expensive test: byte for byte comparison	*/
	if (samecompare(fp) == 0)
		return (FALSE);

	return (TRUE);
}

/*
 * routine:
 *	samestuff
 *
 * purpose:
 *	determine whether or not two files have same owner/protection
 *
 * parameters:
 *	struct file
 *
 * returns:
 *	bool_t (true/false)
 */
static bool_t
samestuff(struct file *fp)
{	int same_mode, same_uid, same_gid, same_acl;
	struct fileinfo *sp, *dp;

	sp = &fp->f_info[OPT_SRC];
	dp = &fp->f_info[OPT_DST];

	same_mode = (sp->f_mode == dp->f_mode);
	same_uid = (sp->f_uid == dp->f_uid);
	same_gid = (sp->f_gid == dp->f_gid);
	same_acl = cmp_acls(sp, dp);

	/* if the are all the same, it is easy to tell the truth	*/
	if (same_uid && same_gid && same_mode && same_acl)
		return (TRUE);

	/* note the nature of the conflict				*/
	if (!same_uid || !same_gid || !same_acl)
		fp->f_problem = gettext(PROB_ownership);
	else
		fp->f_problem = gettext(PROB_protection);

	return (FALSE);
}

/*
 * routine:
 *	samecompare
 *
 * purpose:
 *	do a byte-for-byte comparison of two files
 *
 * parameters:
 *	struct file
 *
 * returns:
 *	bool_t (true/false)
 */
static bool_t
samecompare(struct file *fp)
{	int sfd, dfd;
	int i, count;
	char srcbuf[ COPY_BSIZE ], dstbuf[ COPY_BSIZE ];
	bool_t same = TRUE;


	sfd = open(srcname, 0);
	if (sfd < 0)
		return (FALSE);

	dfd = open(dstname, 0);
	if (dfd < 0) {
		close(sfd);
		return (FALSE);
	}

	for (
	count = read(sfd, srcbuf, COPY_BSIZE);
	count > 0;
	count = read(sfd, srcbuf, COPY_BSIZE)) {

		/* do a matching read				*/
		if (read(dfd, dstbuf, COPY_BSIZE) != count) {
			same = FALSE;
			goto done;
		}

		/* do the comparison for this block		*/
		for (i = 0; i < count; i++) {
			if (srcbuf[i] != dstbuf[i]) {
				same = FALSE;
				goto done;
			}
		}
	}

done:
	if (opt_debug & DBG_ANAL)
		fprintf(stderr, "ANAL: SAME=%d %s\n", same, fp->f_fullname);

	close(sfd);
	close(dfd);
	return (same);
}

/*
 * routine:
 *	truncated
 *
 * purpose:
 *	to determine whether or not a file has been truncated
 *
 * parameters:
 *	pointer to file structure
 *
 * returns:
 *	true/false
 */
static bool_t
truncated(struct file *fp)
{
	/* either source or destination must now be zero length	*/
	if (fp->f_info[OPT_SRC].f_size && fp->f_info[OPT_DST].f_size)
		return (FALSE);

	/* file must have originally had a non-zero length	*/
	if (fp->f_info[OPT_BASE].f_size == 0)
		return (FALSE);

	/* file type must "normal" all around		*/
	if (fp->f_info[OPT_BASE].f_type != S_IFREG)
		return (FALSE);
	if (fp->f_info[OPT_SRC].f_type != S_IFREG)
		return (FALSE);
	if (fp->f_info[OPT_DST].f_type != S_IFREG)
		return (FALSE);


	return (TRUE);
}

/*
 * routine:
 *	samelink
 *
 * purpose:
 *	to determine whether or not two symbolic links agree
 *
 * parameters:
 *	pointer to file structure
 *
 * returns:
 *	true/false
 */
static bool_t
samelink()
{	int i, srclen, dstlen;
	char srcbuf[ MAX_PATH ], dstbuf[ MAX_PATH ];


	/* read both copies of the link			*/
	srclen = readlink(srcname, srcbuf, sizeof (srcbuf));
	dstlen = readlink(dstname, dstbuf, sizeof (dstbuf));

	/* if they aren't the same length, they disagree	*/
	if (srclen < 0 || dstlen < 0 || srclen != dstlen)
		return (FALSE);

	/* look for differences in contents			*/
	for (i = 0; i < srclen; i++)
		if (srcbuf[i] != dstbuf[i])
			return (FALSE);

	return (TRUE);
}

/*
 * routine:
 *	full_name
 *
 * purpose:
 *	to figure out the fully qualified path name to a file on the
 *	reconciliation list.
 *
 * parameters:
 *	pointer to the file structure
 *	side indication for which base to use
 *	side indication for which buffer to use
 *
 * returns:
 *	pointer to a clobberable buffer
 *
 * notes:
 *	the zero'th buffer is used for renames and links, where
 *	we need the name of another file on the same side.
 */
char *
full_name(struct file *fp, side_t srcdst, side_t whichbuf)
{	static char *buffers[3];
	static int buflen = 0;
	char *p, *b;
	int l;

	/* see if the existing buffer is long enough	*/
	b = (srcdst == OPT_SRC) ? fp->f_base->b_src_name
				: fp->f_base->b_dst_name;

	/* see if the allocated buffer is long enough		*/
	l = strlen(b) + strlen(fp->f_fullname) + 2;
	if (l > buflen) {
		/* figure out the next "nice" size to use	*/
		for (buflen = MAX_PATH; buflen < l; buflen += MAX_NAME);

		/* reallocate all buffers to this size		*/
		for (l = 0; l < 3; l++) {
			buffers[l] = (char *) realloc(buffers[l], buflen);
			if (buffers[l] == 0)
				nomem("full name");
		}
	}

	/* assemble the name in the buffer and reurn it	*/
	p = buffers[whichbuf];
	strcpy(p, b);
	strcat(p, "/");
	strcat(p, fp->f_fullname);
	return (p);
}