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