cmd/filesync/action.c

/*
 * 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);
}