xref: /titanic_52/usr/src/cmd/filesync/action.c (revision 2b24ab6b3865caeede9eeb9db6b83e1d89dcd1ea)

/*
 * 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:
 *	action.c
 *
 * purpose:
 *	routines to carryout reconciliation actions and make the
 *	appropriate updates to the database file structure.
 *
 * contents:
 *	do_like ... change ownership and protection
 *	do_copy ... copy a file from one side to the other
 *	do_remove . remove a file from one side
 *	do_rename . rename a file on one side
 *	copy ...... (static) do the actual copy
 *	checksparse (static) figure out if a file is sparse
 *
 * ASSERTIONS:
 *	any of these action routines is responsible for all baseline
 *	and statistics updates associated with the reconciliation
 *	actions.  If notouch is specified, they should fake the
 *	updates well enough so that link tests will still work.
 *
 *	success:
 *		bump bp->b_{src,dst}_{copies,deletes,misc}
 *		update fp->f_info[srcdst]
 *		update fp->f_info[OPT_BASE] from fp->f_info[srcdst]
 *		if there might be multiple links, call link_update
 *		return ERR_RESOLVABLE
 *
 *	failure:
 *		set fp->f_flags |= F_CONFLICT
 *		set fp->f_problem
 *		bump bp->b_unresolved
 *		return ERR_UNRESOLVED
 *
 *	pretend this never happened:
 *		return 0, and baseline will be unchanged
 *
 * notes:
 *	Action routines can be called in virtually any order
 *	or combination, and it is certainly possible for an
 *	earlier action to succeed while a later action fails.
 *	If each successful action results in a completed baseline
 *	update, a subsequent failure will force the baseline to
 *	roll back to the last success ... which is appropriate.
 */
#ident	"%W%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <utime.h>
#include <errno.h>
#include <sys/mkdev.h>
#include <sys/statvfs.h>

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

/*
 * globals and importeds
 */
bool_t need_super;	/* warn user that we can't fix ownership	*/
extern char *srcname;	/* file we are emulating			*/
extern char *dstname;	/* file we are updating				*/

/*
 * locals
 */
static errmask_t copy(char *, char *, int);
static int checksparse(int);
static char *copy_err_str;		/* what went wrong w/copy	*/

/*
 * routine:
 *	do_like
 *
 * purpose:
 *	to propagate ownership and protection changes between
 *	one existing file and another.
 *
 * parameters:
 *	file pointer
 *	src/dst indication for who needs to change
 *	whether or not to update statistics (there may be a copy and a like)
 *
 * returns:
 *	error mask
 *
 * notes:
 *	if we are called from reconcile, we should update
 *	the statistics, but if we were called from do_copy
 *	that routine will do the honors.
 */
errmask_t
do_like(struct file *fp, side_t srcdst, bool_t do_stats)
{	char *dst;
	int rc = 0;
	int do_chown, do_chmod, do_chgrp, do_acls;
	errmask_t errs = 0;
	char *errstr = 0;
	struct base *bp;
	struct fileinfo *sp;
	struct fileinfo *dp;
	struct fileinfo *ip;
	extern int errno;

	bp = fp->f_base;

	/* see if this is a forbidden propagation */
	if (srcdst == opt_oneway) {
		fp->f_flags |= F_CONFLICT;
		fp->f_problem = gettext(PROB_prohibited);
		bp->b_unresolved++;
		return (ERR_UNRESOLVED);
	}


	/* get info about source and target files		*/
	if (srcdst == OPT_SRC) {
		sp = &fp->f_info[ OPT_DST ];
		dp = &fp->f_info[ OPT_SRC ];
		dst = srcname;
	} else {
		sp = &fp->f_info[ OPT_SRC ];
		dp = &fp->f_info[ OPT_DST ];
		dst = dstname;
	}
	ip = &fp->f_info[ OPT_BASE ];

	/* figure out what needs fixing				*/
	do_chmod = (sp->f_mode != dp->f_mode);
	do_chown = (sp->f_uid != dp->f_uid);
	do_chgrp = (sp->f_gid != dp->f_gid);
	do_acls  = ((fp->f_srcdiffs|fp->f_dstdiffs) & D_FACLS);

	/*
	 * try to anticipate things that we might not be able to
	 * do, and return appropriate errorst if the calling user
	 * cannot safely perform the requiested updates.
	 */
	if (my_uid != 0) {
		if (do_chown)
			errstr = gettext(PROB_chown);
		else if (my_uid != dp->f_uid) {
			if (do_chmod)
				errstr = gettext(PROB_chmod);
			else if (do_acls)
				errstr = gettext(PROB_chacl);
			else if (do_chgrp)
				errstr = gettext(PROB_chgrp);
		}
#ifdef	ACL_UID_BUG
		else if (do_acls && my_gid != dp->f_gid)
			errstr = gettext(PROB_botch);
#endif

		if (errstr) {
			need_super = TRUE;

			/* if the user doesn't care, shine it on	*/
			if (opt_everything == 0)
				return (0);

			/* if the user does care, return the error	*/
			rc = -1;
			goto nogood;
		}
	}

	if (opt_debug & DBG_RECON) {
		fprintf(stderr, "RECO: do_like %s (", dst);
		if (do_chmod)
			fprintf(stderr, "chmod ");
		if (do_acls)
			fprintf(stderr, "acls ");
		if (do_chown)
			fprintf(stderr, "chown ");
		if (do_chgrp)
			fprintf(stderr, "chgrp ");
		fprintf(stderr, ")\n");
	}

	if (do_chmod) {
		if (!opt_quiet)
			fprintf(stdout, "chmod %o %s\n", sp->f_mode,
						noblanks(dst));

#ifdef	DBG_ERRORS
		/* should we simulate a chmod failure	*/
		if (errno = dbg_chk_error(dst, 'p'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : chmod(dst, sp->f_mode);

		if (opt_debug & DBG_RECON)
			fprintf(stderr, "RECO: do_chmod %o -> %d(%d)\n",
				sp->f_mode, rc, errno);

		/* update dest and baseline to reflect the change */
		if (rc == 0) {
			dp->f_mode = sp->f_mode;
			ip->f_mode = sp->f_mode;
		} else
			errstr = gettext(PROB_chmod);
	}

	/*
	 * see if we need to fix the acls
	 */
	if (rc == 0 && do_acls) {
		if (!opt_quiet)
			fprintf(stdout, "setfacl %s %s\n",
				show_acls(sp->f_numacls, sp->f_acls),
				noblanks(dst));

#ifdef	DBG_ERRORS
		/* should we simulate a set acl failure	*/
		if (errno = dbg_chk_error(dst, 'a'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : set_acls(dst, sp);

		if (opt_debug & DBG_RECON)
			fprintf(stderr, "RECO: do_acls %d -> %d(%d)\n",
				sp->f_numacls, rc, errno);

		/* update dest and baseline to reflect the change */
		if (rc == 0) {
			dp->f_numacls = sp->f_numacls;
			dp->f_acls = sp->f_acls;
			ip->f_numacls = sp->f_numacls;
			ip->f_acls = sp->f_acls;
#ifdef	ACL_UID_BUG
			/* SETFACL changes a file's UID/GID	*/
			if (my_uid != dp->f_uid) {
				do_chown = 1;
				dp->f_uid = my_uid;
			}
			if (my_gid != dp->f_gid) {
				do_chgrp = 1;
				dp->f_gid = my_gid;
			}
#endif
		} else if (errno == ENOSYS) {
			/*
			 * if the file system doesn't support ACLs
			 * we should just pretend we never saw them
			 */
			fprintf(stderr, gettext(WARN_noacls), dst);
			ip->f_numacls = 0;
			sp->f_numacls = 0;
			dp->f_numacls = 0;
			rc = 0;
		} else
			errstr = gettext(PROB_chacl);
	}

	/*
	 * see if we need to fix the ownership
	 */
	if (rc == 0 && (do_chown || do_chgrp)) {
		if (do_chown)
			fprintf(stdout, "chown %ld %s; ",
				sp->f_uid, noblanks(dst));
		if (do_chgrp)
			fprintf(stdout, "chgrp %ld %s",
				sp->f_gid, noblanks(dst));

		fprintf(stdout, "\n");

#ifdef	DBG_ERRORS
		/* should we simulate a chown failure	*/
		if (errno = dbg_chk_error(dst, 'O'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : lchown(dst, sp->f_uid, sp->f_gid);

		if (opt_debug & DBG_RECON)
			fprintf(stderr, "RECO: do_chown %ld %ld -> %d(%d)\n",
					sp->f_uid, sp->f_gid, rc, errno);

		/* update the destination to reflect changes */
		if (rc == 0) {
			dp->f_uid = sp->f_uid;
			dp->f_gid = sp->f_gid;
			ip->f_uid = sp->f_uid;
			ip->f_gid = sp->f_gid;
		} else {
			if (errno == EPERM) {
				need_super = TRUE;
				if (opt_everything == 0)
					return (0);
			}

			if (rc != 0)
				errstr = gettext(do_chown ?
						PROB_chown : PROB_chgrp);
		}
	}

	/*
	 * if we were successful, we should make sure the other links
	 * see the changes.  If we were called from do_copy, we don't
	 * want to do the link_updates either because do_copy will
	 * handle them too.
	 */
	if (rc == 0 && do_stats)
		link_update(fp, srcdst);

nogood:
	if (!do_stats)
		return (errs);

	if (rc != 0) {
		fprintf(stderr, gettext(ERR_cannot), errstr, dst);
		fp->f_problem = errstr;
		fp->f_flags |= F_CONFLICT;
		bp->b_unresolved++;
		errs |= ERR_PERM | ERR_UNRESOLVED;
	} else {
		/*
		 * it worked, so update the baseline and statistics
		 */
		if (srcdst == OPT_SRC)
			bp->b_src_misc++;
		else
			bp->b_dst_misc++;

		fp->f_problem = 0;
		errs |= ERR_RESOLVABLE;
	}

	return (errs);
}

/*
 * routine:
 *	do_copy
 *
 * purpose:
 *	to propagate a creation or change
 *
 * parameters:
 *	file pointer
 *	src/dst indication for who gets the copy
 *
 * returns:
 *	error mask
 *
 * note:
 *	after any successful operation we update the stat/info
 *	structure for the updated file.  This is somewhat redundant
 *	because we will restat at the end of the routine, but these
 *	anticipatory updates help to ensure that the link finding
 *	code will still behave properly in notouch mode (when restats
 *	cannot be done).
 */
errmask_t
do_copy(struct file *fp, side_t srcdst)
{	char *src, *dst;
	char cmdbuf[ MAX_PATH + MAX_NAME ];
	int mode, maj, min, type;
	uid_t uid;
	gid_t gid;
	int rc;
	long mtime;
	int do_chmod = 0;
	int do_chown = 0;
	int do_chgrp = 0;
	int do_unlink = 0;
	int do_acls = 0;
	int do_create = 0;
	char *errstr = "???";
	errmask_t errs = 0;
	struct base *bp;
	struct file *lp;
	struct fileinfo *sp, *dp;
	struct utimbuf newtimes;
	struct stat statb;

	bp = fp->f_base;

	/* see if this is a forbidden propagation */
	if (srcdst == opt_oneway) {
		fp->f_problem = gettext(PROB_prohibited);
		fp->f_flags |= F_CONFLICT;
		bp->b_unresolved++;
		return (ERR_UNRESOLVED);
	}

	/* figure out who is the source and who is the destination	*/
	if (srcdst == OPT_SRC) {
		sp = &fp->f_info[ OPT_DST ];
		dp = &fp->f_info[ OPT_SRC ];
		src = dstname;
		dst = srcname;
	} else {
		sp = &fp->f_info[ OPT_SRC ];
		dp = &fp->f_info[ OPT_DST ];
		src = srcname;
		dst = dstname;
	}

	/* note information about the file to be created		*/
	type  = sp->f_type;		/* type of the new file		*/
	uid   = sp->f_uid;		/* owner of the new file	*/
	gid   = sp->f_gid;		/* group of the new file	*/
	mode  = sp->f_mode;		/* modes for the new file	*/
	mtime = sp->f_modtime;		/* modtime (if preserving)	*/
	maj   = sp->f_rd_maj;		/* major (if it is a device)	*/
	min   = sp->f_rd_min;		/* minor (if it is a device)	*/

	/*
	 * creating a file does not guarantee it will get the desired
	 * modes, uid and gid.  If the file already exists, it will
	 * retain its old ownership and protection.  If my UID/GID
	 * are not the desired ones, the new file will also require
	 * manual correction.  If the file has the wrong type, we will
	 * need to delete it and recreate it.  If the file is not writable,
	 * it is easier to delete it than to chmod it to permit overwrite
	 */
	if ((dp->f_type == S_IFREG && sp->f_type == S_IFREG) &&
	    (dp->f_mode & 0200)) {
		/* if the file already exists		*/
		if (dp->f_uid != uid)
			do_chown = 1;

		if (dp->f_gid != gid)
			do_chgrp = 1;

		if (dp->f_mode != mode)
			do_chmod = 1;
	} else {
		/* if we will be creating a new file	*/
		do_create = 1;
		if (dp->f_type)
			do_unlink = 1;
		if (uid != my_uid)
			do_chown = 1;
		if (gid != my_gid)
			do_chgrp = 1;
	}

	/*
	 * if the source has acls, we will surely have to set them for dest
	 */
	if (sp->f_numacls)
		do_acls = 1;

	/*
	 * for any case other than replacing a normal file with a normal
	 * file, we need to delete the existing file before creating
	 * the new one.
	 */
	if (do_unlink) {
		if (dp->f_type == S_IFDIR) {
			if (!opt_quiet)
				fprintf(stdout, "rmdir %s\n", noblanks(dst));

			errstr = gettext(PROB_rmdir);
#ifdef	DBG_ERRORS
			/* should we simulate a rmdir failure	*/
			if (errno = dbg_chk_error(dst, 'D'))
				rc = -1;
			else
#endif
			rc = opt_notouch ? 0 : rmdir(dst);
		} else {
			if (!opt_quiet)
				fprintf(stdout, "rm %s\n", noblanks(dst));

			errstr = gettext(PROB_unlink);
#ifdef	DBG_ERRORS
			/* should we simulate a unlink failure	*/
			if (errno = dbg_chk_error(dst, 'u'))
				rc = -1;
			else
#endif
			rc = opt_notouch ? 0 : unlink(dst);
		}

		if (rc != 0)
			goto cant;

		/* note that this file no longer exists		*/
		dp->f_type = 0;
		dp->f_mode = 0;
	}

	if (opt_debug & DBG_RECON) {
		fprintf(stderr, "RECO: do_copy %s %s (", src, dst);
		if (do_unlink)
			fprintf(stderr, "unlink ");
		if (do_chmod)
			fprintf(stderr, "chmod ");
		if (do_acls)
			fprintf(stderr, "acls ");
		if (do_chown)
			fprintf(stderr, "chown ");
		if (do_chgrp)
			fprintf(stderr, "chgrp ");
		fprintf(stderr, ")\n");
	}

	/*
	 * how we go about copying a file depends on what type of file
	 * it is that we are supposed to copy
	 */
	switch (type) {
	    case S_IFDIR:
		if (!opt_quiet) {
			fprintf(stdout, "mkdir %s;", noblanks(dst));
			fprintf(stdout, " chmod %o %s;\n", mode, noblanks(dst));
		}

		errstr = gettext(PROB_mkdir);

#ifdef	DBG_ERRORS
		/* should we simulate a mkdir failure	*/
		if (errno = dbg_chk_error(dst, 'd'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : mkdir(dst, mode);

		/* update stat with what we have just created	*/
		if (rc == 0) {
			dp->f_type = S_IFDIR;
			dp->f_uid = my_uid;
			dp->f_gid = my_gid;
			dp->f_mode = mode;
		}

		break;

	    case S_IFLNK:
		errstr = gettext(PROB_readlink);
#ifdef	DBG_ERRORS
		/* should we simulate a symlink read failure	*/
		if (errno = dbg_chk_error(dst, 'r'))
			rc = -1;
		else
#endif
		rc = readlink(src, cmdbuf, sizeof (cmdbuf));
		if (rc > 0) {
			cmdbuf[rc] = 0;
			if (!opt_quiet) {
				fprintf(stdout, "ln -s %s", noblanks(cmdbuf));
				fprintf(stdout, " %s;\n", noblanks(dst));
			}
			errstr = gettext(PROB_symlink);
#ifdef	DBG_ERRORS
			/* should we simulate a symlink failure	*/
			if (errno = dbg_chk_error(dst, 'l'))
				rc = -1;
			else
#endif
			rc = opt_notouch ? 0 : symlink(cmdbuf, dst);

			if (rc == 0)
				dp->f_type = S_IFLNK;
		}
		break;

	    case S_IFBLK:
	    case S_IFCHR:
		if (!opt_quiet)
			fprintf(stdout, "mknod %s %s %d %d\n", noblanks(dst),
				(type == S_IFBLK) ? "b" : "c", maj, min);

		errstr = gettext(PROB_mknod);
#ifdef	DBG_ERRORS
		/* should we simulate a mknod failure	*/
		if (errno = dbg_chk_error(dst, 'd'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0
				: mknod(dst, mode|type, makedev(maj, min));

		/* update stat with what we have just created	*/
		if (rc == 0) {
			dp->f_type = type;
			dp->f_uid = my_uid;
			dp->f_gid = my_gid;
			dp->f_mode = 0666;

			if (dp->f_mode != mode)
				do_chmod = 1;
		}
		break;

	    case S_IFREG:
		/*
		 * The first thing to do is ascertain whether or not
		 * the alleged new copy might in fact be a new link.
		 * We trust find_link to weigh all the various factors,
		 * so if he says make a link, we'll do it.
		 */
		lp = find_link(fp, srcdst);
		if (lp) {
			/* figure out name of existing file	*/
			src = full_name(lp, srcdst, OPT_BASE);

			/*
			 * if file already exists, it must be deleted
			 */
			if (dp->f_type) {
				if (!opt_quiet)
					fprintf(stdout, "rm %s\n",
						noblanks(dst));

				errstr = gettext(PROB_unlink);
#ifdef	DBG_ERRORS
				/* should we simulate a unlink failure	*/
				if (errno = dbg_chk_error(dst, 'u'))
					rc = -1;
				else
#endif
				rc = opt_notouch ? 0 : unlink(dst);

				/*
				 * if we couldn't do the unlink, we must
				 * mark the linkee in conflict as well
				 * so his reference count remains the same
				 * in the baseline and he continues to show
				 * up on the change list.
				 */
				if (rc != 0) {
					lp->f_flags |= F_CONFLICT;
					lp->f_problem = gettext(PROB_link);
					goto cant;
				}
			}

			if (!opt_quiet) {
				fprintf(stdout, "ln %s", noblanks(src));
				fprintf(stdout, " %s\n", noblanks(dst));
			}
			errstr = gettext(PROB_link);

#ifdef	DBG_ERRORS
			/* should we simulate a link failure	*/
			if (errno = dbg_chk_error(dst, 'l'))
				rc = -1;
			else
#endif
			rc = opt_notouch ? 0 : link(src, dst);

			/*
			 * if this is a link, there is no reason to worry
			 * about ownership and modes, they are automatic
			 */
			do_chown = 0; do_chgrp = 0; do_chmod = 0; do_acls = 0;
			if (rc == 0) {
				dp->f_type = type;
				dp->f_uid = uid;
				dp->f_gid = gid;
				dp->f_mode = mode;
				break;
			} else {
				/*
				 * if we failed to make a link, we want to
				 * mark the linkee in conflict too, so that
				 * his reference count remains the same in
				 * the baseline, and he shows up on the change
				 * list again next time.
				 */
				lp->f_flags |= F_CONFLICT;
				lp->f_problem = errstr;
				break;
			}

			/*
			 * in some situation we haven't figured out yet
			 * we might want to fall through and try a copy
			 * if the link failed.
			 */
		}

		/* we are going to resolve this by making a copy	*/
		if (!opt_quiet) {
			fprintf(stdout, "cp %s", noblanks(src));
			fprintf(stdout, " %s\n", noblanks(dst));
		}
		rc = opt_notouch ? 0 : copy(src, dst, mode);
		if (rc != 0) {
			errs |= rc;
			if (copy_err_str)
				errstr = copy_err_str;
			else
				errstr = gettext(PROB_copy);

			/*
			 * The new copy (if it exists at all) is a botch.
			 * If this was a new create or a remove and copy
			 * we should get rid of the botched copy so that
			 * it doesn't show up as two versions next time.
			 */
			if (do_create)
				unlink(dst);
		} else if (dp->f_mode == 0) {
			dp->f_type = S_IFREG;
			dp->f_uid = my_uid;
			dp->f_gid = my_gid;
			dp->f_mode = mode;

			/* FIX: inode number is still wrong	*/
		}

		/* for normal files we have an option to preserve mod time  */
		if (rc == 0 && opt_notouch == 0 && opt_mtime) {
			newtimes.actime = mtime;
			newtimes.modtime = mtime;

			/* ignore the error return on this one	*/
			(void) utime(dst, &newtimes);
		}
		break;

	    default:
		errstr = gettext(PROB_deal);
		rc = -1;
	}

	/*
	 * if any of the file's attributes need attention, I should let
	 * do_like take care of them, since it knows all rules for who
	 * can and cannot make what types of changes.
	 */
	if (rc == 0 && (do_chmod || do_chown || do_chgrp || do_acls)) {
		rc = do_like(fp, srcdst, FALSE);
		errstr = fp->f_problem;
		errs |= rc;
	}

	/*
	 * finish off by re-stating the destination and using that to
	 * update the baseline.  If we were completely successful in
	 * our chowns/chmods, stating the destination will confirm it.
	 * If we were unable to make all the necessary changes, stating
	 * the destination will make the source appear to have changed,
	 * so that the differences will continue to reappear as new
	 * changes (inconsistancies).
	 */
	if (rc == 0)
		if (!opt_notouch) {
			errstr = gettext(PROB_restat);

#ifdef	DBG_ERRORS
			/* should we simulate a restat failure	*/
			if (errno = dbg_chk_error(dst, 'R'))
				rc = -1;
			else
#endif
			rc = lstat(dst, &statb);

			if (rc == 0) {
				note_info(fp, &statb, srcdst);
				link_update(fp, srcdst);
				if (do_acls)
					(void) get_acls(dst, dp);
				update_info(fp, srcdst);
			}
		} else {
			/*
			 * BOGOSITY ALERT
			 *	we are in notouch mode and haven't really
			 *	done anything, but if we want link detection
			 *	to work and be properly reflected in the
			 *	what-I-would-do output for a case where
			 *	multiple links are created to a new file,
			 *	we have to make the new file appear to
			 *	have been created.  Since we didn't create
			 *	the new file we can't stat it, but if
			 *	no file exists, we can't make a link to
			 *	it, so we will pretend we created a file.
			 */
			if (dp->f_ino == 0 || dp->f_nlink == 0) {
				dp->f_ino = sp->f_ino;
				dp->f_nlink = 1;
			}
		}

cant:	if (rc != 0) {
		fprintf(stderr, gettext(ERR_cannot), errstr, dst);
		bp->b_unresolved++;
		fp->f_flags |= F_CONFLICT;
		fp->f_problem = errstr;
		if (errs == 0)
			errs = ERR_PERM;
		errs |= ERR_UNRESOLVED;
	} else {
		/* update the statistics			*/
		if (srcdst == OPT_SRC)
			bp->b_src_copies++;
		else
			bp->b_dst_copies++;
		errs |= ERR_RESOLVABLE;
	}

	return (errs);
}

/*
 * routine:
 *	do_remove
 *
 * purpose:
 *	to propagate a deletion
 *
 * parameters:
 *	file pointer
 *	src/dst indication for which side gets changed
 *
 * returns:
 *	error mask
 */
errmask_t
do_remove(struct file *fp, side_t srcdst)
{	char *name;
	int rc;
	struct base *bp = fp->f_base;
	errmask_t errs = 0;
	char *errstr = "???";

	/* see if this is a forbidden propagation */
	if (srcdst == opt_oneway) {
		fp->f_problem = gettext(PROB_prohibited);
		fp->f_flags |= F_CONFLICT;
		bp->b_unresolved++;
		return (ERR_UNRESOLVED);
	}

	name = (srcdst == OPT_SRC) ? srcname : dstname;

	if (fp->f_info[0].f_type == S_IFDIR) {
		if (!opt_quiet)
			fprintf(stdout, "rmdir %s\n", noblanks(name));

		errstr = gettext(PROB_rmdir);

#ifdef	DBG_ERRORS
		/* should we simulate a rmdir failure	*/
		if (errno = dbg_chk_error(name, 'D'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : rmdir(name);
	} else {
		if (!opt_quiet)
			fprintf(stdout, "rm %s\n", noblanks(name));

		errstr = gettext(PROB_unlink);

#ifdef	DBG_ERRORS
		/* should we simulate an unlink failure	*/
		if (errno = dbg_chk_error(name, 'u'))
			rc = -1;
		else
#endif
		rc = opt_notouch ? 0 : unlink(name);
	}

	if (opt_debug & DBG_RECON)
		fprintf(stderr, "RECO: do_remove %s -> %d(%d)\n",
			name, rc, errno);

	if (rc == 0) {
		/* tell any other hard links that one has gone away	*/
		fp->f_info[srcdst].f_nlink--;
		link_update(fp, srcdst);

		fp->f_flags |= F_REMOVE;
		if (srcdst == OPT_SRC)
			fp->f_base->b_src_deletes++;
		else
			fp->f_base->b_dst_deletes++;
		errs |= ERR_RESOLVABLE;
	} else {
		fprintf(stderr, gettext(ERR_cannot), errstr, name);
		fp->f_problem = errstr;
		fp->f_flags |= F_CONFLICT;
		bp->b_unresolved++;
		errs |= ERR_PERM | ERR_UNRESOLVED;
	}

	return (errs);
}

/*
 * routine:
 *	do_rename
 *
 * purpose:
 *	to propagate a rename
 *
 * parameters:
 *	file pointer for the new name
 *	src/dst indication for which side gets changed
 *
 * returns:
 *	error mask
 */
errmask_t
do_rename(struct file *fp, side_t srcdst)
{	int rc;
	struct file *pp = fp->f_previous;
	struct base *bp = fp->f_base;
	errmask_t errs = 0;
	char *errstr = "???";
	char *newname;
	char *oldname;
	struct stat statb;

	/* see if this is a forbidden propagation */
	if (srcdst == opt_oneway) {
		fp->f_problem = gettext(PROB_prohibited);

		/* if we can't resolve the TO, the FROM is also unresolved */
		pp->f_problem = gettext(PROB_prohibited);
		pp->f_flags |= F_CONFLICT;
		bp->b_unresolved++;
		return (ERR_UNRESOLVED);
	}

	newname = (srcdst == OPT_SRC) ? srcname : dstname;
	oldname = full_name(pp, srcdst, OPT_BASE);

	if (!opt_quiet)
		fprintf(stdout, "%s %s %s\n",
			(fp->f_info[0].f_type == S_IFDIR) ? "mvdir" : "mv",
			noblanks(oldname), noblanks(newname));

#ifdef	DBG_ERRORS
	/* should we simulate a rename failure	*/
	if (errno = dbg_chk_error(oldname, 'm'))
		rc = -1;
	else
#endif
	rc = opt_notouch ? 0 : rename(oldname, newname);

	if (opt_debug & DBG_RECON)
		fprintf(stderr, "RECO: do_rename %s %s -> %d(%d)\n",
			oldname, newname, rc, errno);

	/* if we succeed, update the baseline			*/
	if (rc == 0)
		if (!opt_notouch) {
			errstr = gettext(PROB_restat);

#ifdef	DBG_ERRORS
			/* should we simulate a restat failure	*/
			if (errno = dbg_chk_error(newname, 'S'))
				rc = -1;
			else
#endif
			rc = lstat(newname, &statb);

			if (rc == 0) {
				note_info(fp, &statb, srcdst);
				link_update(fp, srcdst);
				update_info(fp, srcdst);
			}
		} else {
			/*
			 * BOGOSITY ALERT
			 * in order for link tests to work in notouch
			 * mode we have to dummy up some updated status
			 */
			fp->f_info[srcdst].f_ino = pp->f_info[srcdst].f_ino;
			fp->f_info[srcdst].f_nlink = pp->f_info[srcdst].f_nlink;
			fp->f_info[srcdst].f_type = pp->f_info[srcdst].f_type;
			fp->f_info[srcdst].f_size = pp->f_info[srcdst].f_size;
			fp->f_info[srcdst].f_mode = pp->f_info[srcdst].f_mode;
			fp->f_info[srcdst].f_uid = pp->f_info[srcdst].f_uid;
			fp->f_info[srcdst].f_gid = pp->f_info[srcdst].f_gid;
			update_info(fp, srcdst);
		}
	else
		errstr = gettext(PROB_rename2);

	if (rc == 0) {
		pp->f_flags |= F_REMOVE;

		if (srcdst == OPT_SRC) {
			bp->b_src_copies++;
			bp->b_src_deletes++;
		} else {
			bp->b_dst_copies++;
			bp->b_dst_deletes++;
		}
		errs |= ERR_RESOLVABLE;
	} else {
		fprintf(stderr, gettext(ERR_cannot), errstr, oldname);

		bp->b_unresolved++;
		fp->f_flags |= F_CONFLICT;
		pp->f_flags |= F_CONFLICT;

		fp->f_problem = errstr;
		pp->f_problem = gettext(PROB_rename);

		errs |= ERR_PERM | ERR_UNRESOLVED;
	}

	return (errs);
}

/*
 * routine:
 *	copy
 *
 * purpose:
 *	to copy one file to another
 *
 * parameters:
 *	source file name
 *	destination file name
 *	desired modes
 *
 * returns:
 *	0	OK
 *	else	error mask, and a setting of copy_err_str
 *
 * notes:
 *	We try to preserve the holes in sparse files, by skipping over
 *	any holes that are at least MIN_HOLE bytes long.  There are
 *	pathological cases where the hole detection test could become
 *	expensive, but for most blocks of most files we will fall out
 *	of the zero confirming loop in the first couple of bytes.
 */
static errmask_t
copy(char *src, char *dst, int mode)
{	int ifd, ofd, count, ret;
	long *p, *e;
	long long length;		/* total size of file	*/
	errmask_t errs = 0;
	int bsize;			/* block-size for file	*/
	bool_t sparse;			/* file may be sparse	*/
	bool_t was_hole = FALSE;		/* file ends with hole	*/
	long inbuf[ COPY_BSIZE/4 ];	/* long to speed checks	*/
	struct stat statbuf;		/* info on source file	*/
	struct statvfs statvsbuf;	/* info on target fs	*/

	copy_err_str = 0;

	/* open the input file			*/
#ifdef	DBG_ERRORS
	if (opt_errors && dbg_chk_error(src, 'o'))
		ifd = -1;
	else
#endif
	ifd = open(src, O_RDONLY);

	if (ifd < 0) {
		copy_err_str = gettext(PROB_copyin);
		return (ERR_PERM);
	}

	/*
	 * if we suspect a file may be sparse, we must process it
	 * a little more carefully, looking for holes and skipping
	 * over them in the output.  If a file is not sparse, we
	 * can move through it at greater speed.
	 */
	bsize = checksparse(ifd);
	if (bsize > 0 && bsize <= COPY_BSIZE)
		sparse = TRUE;
	else {
		sparse = FALSE;
		bsize = COPY_BSIZE;
	}

	/*
	 * if the target file already exists and we overwrite it without
	 * first ascertaining that there is enough room, we could wind
	 * up actually losing data.  Try to determine how much space is
	 * available on the target file system, and if that is not enough
	 * for the source file, fail without even trying.  If, however,
	 * the target file does not already exist, we have nothing to
	 * lose by just doing the copy without checking the space.
	 */
	ret = statvfs(dst, &statvsbuf);
	if (ret == 0 && statvsbuf.f_frsize != 0) {
#ifdef	DBG_ERRORS
		/* should we simulate an out-of-space situation	*/
		if ((length = dbg_chk_error(dst, 'Z')) == 0)
#endif
		length = statvsbuf.f_bavail * statvsbuf.f_frsize;

		ret = fstat(ifd, &statbuf);
		if (ret == 0) {
			length /= 512;		/* st_blocks in 512s	*/
			if (length < statbuf.st_blocks) {
				copy_err_str = gettext(PROB_space);
				close(ifd);
				return (ERR_FILES);
			}
		} else {
			copy_err_str = gettext(PROB_restat);
			close(ifd);
			return (ERR_FILES);
		}
	}

	/* create the output file		*/
#ifdef	DBG_ERRORS
	if (opt_errors && dbg_chk_error(dst, 'c'))
		ofd = -1;
	else
#endif
	ofd = creat(dst, mode);

	if (ofd < 0) {
		close(ifd);
		copy_err_str = gettext(PROB_copyout);
		return (ERR_PERM);
	}

	/* copy the data from the input file to the output file	*/
	for (;;) {
#ifdef	DBG_ERRORS
		if (opt_errors && dbg_chk_error(dst, 'r'))
			count = -1;
		else
#endif
		count = read(ifd, (char *) inbuf, bsize);
		if (count <= 0)
			break;

		/*
		 * if the file might be sparse and we got an entire block,
		 * we should see if the block is all zeros
		 */
		if (sparse && count == bsize) {
			p = inbuf; e = &inbuf[count/4];
			while (p < e && *p == 0)
				p++;
			if (p == e) {
				(void) lseek(ofd, (off_t) count, SEEK_CUR);
				was_hole = TRUE;
				continue;
			}
		}
		was_hole = FALSE;

#ifdef	DBG_ERRORS
		if (opt_errors && dbg_chk_error(dst, 'w'))
			ret = -1;
		else
#endif
		ret = write(ofd, (char *) inbuf, count);

		if (ret != count) {
			errs = ERR_FILES;
			copy_err_str = gettext(PROB_write);
			break;
		}
	}

	if (count < 0) {
		copy_err_str = gettext(PROB_read);
		errs = ERR_FILES;
	} else if (was_hole) {
		/*
		 * if we skipped the last write because of a hole, we
		 * need to make sure that we write a single byte of null
		 * at the end of the file to update the file length.
		 */
		(void) lseek(ofd, (off_t)-1, SEEK_CUR);
		(void) write(ofd, "", 1);
	}

	/*
	 * if the output file was botched, free up its space
	 */
	if (errs)
		ftruncate(ofd, (off_t) 0);

	close(ifd);
	close(ofd);
	return (errs);
}

/*
 * routine:
 *	checksparse
 *
 * purpose:
 *	to determine whether or not a file might be sparse, and if
 *	it is sparse, what the granularity of the holes is likely
 *	to be.
 *
 * parameters:
 *	file descriptor for file in question
 *
 * returns:
 *	0	file does not appear to be sparse
 *	else	block size for this file
 */
static int
checksparse(int fd)
{
	struct stat statb;

	/*
	 * unable to stat the file is very strange (since we got it
	 * open) but it probably isn't worth causing a fuss over.
	 * Return the conservative answer
	 */
	if (fstat(fd, &statb) < 0)
		return (MIN_HOLE);

	/*
	 * if the file doesn't have enough blocks to account for
	 * all of its bytes, there is a reasonable chance that it
	 * is sparse.  This test is not perfect, in that it will
	 * fail to find holes in cases where the holes aren't
	 * numerous enough to componsent for the indirect blocks
	 * ... but losing those few holes is not going to be a
	 * big deal.
	 */
	if (statb.st_size > 512 * statb.st_blocks)
		return (statb.st_blksize);
	else
		return (0);
}