--- old/usr/src/cmd/filesync/recon.c	2017-05-26 19:16:44.790885955 -0400
+++ /dev/null	2017-05-26 19:16:44.000000000 -0400
@@ -1,833 +0,0 @@
-/*
- * 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);
-}
