Home | History | Annotate | Line # | Download | only in mtree
compare.c revision 1.42 
      1 /*	$NetBSD: compare.c,v 1.42 2002/10/08 00:34:08 lukem Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1989, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #include <sys/cdefs.h>
     37 #if defined(__RCSID) && !defined(lint)
     38 #if 0
     39 static char sccsid[] = "@(#)compare.c	8.1 (Berkeley) 6/6/93";
     40 #else
     41 __RCSID("$NetBSD: compare.c,v 1.42 2002/10/08 00:34:08 lukem Exp $");
     42 #endif
     43 #endif /* not lint */
     44 
     45 #include <sys/param.h>
     46 
     47 #include <errno.h>
     48 #include <fcntl.h>
     49 #include <stdio.h>
     50 #include <string.h>
     51 #include <time.h>
     52 #include <unistd.h>
     53 
     54 #ifndef NO_MD5
     55 #include <md5.h>
     56 #endif
     57 #ifndef NO_RMD160
     58 #include <rmd160.h>
     59 #endif
     60 #ifndef NO_SHA1
     61 #include <sha1.h>
     62 #endif
     63 
     64 #include "extern.h"
     65 
     66 #define	INDENTNAMELEN	8
     67 #define MARK								\
     68 do {									\
     69 	len = printf("%s: ", RP(p));					\
     70 	if (len > INDENTNAMELEN) {					\
     71 		tab = "\t";						\
     72 		printf("\n");						\
     73 	} else {							\
     74 		tab = "";						\
     75 		printf("%*s", INDENTNAMELEN - (int)len, "");		\
     76 	}								\
     77 } while (0)
     78 #define	LABEL if (!label++) MARK
     79 
     80 #if HAVE_STRUCT_STAT_ST_FLAGS
     81 
     82 
     83 #define CHANGEFLAGS							\
     84 	if (flags != p->fts_statp->st_flags) {				\
     85 		if (!label) {						\
     86 			MARK;						\
     87 			printf("%sflags (\"%s\"", tab,			\
     88 			    flags_to_string(p->fts_statp->st_flags, "none")); \
     89 		}							\
     90 		if (lchflags(p->fts_accpath, flags)) {			\
     91 			label++;					\
     92 			printf(", not modified: %s)\n",			\
     93 			    strerror(errno));				\
     94 		} else							\
     95 			printf(", modified to \"%s\")\n",		\
     96 			     flags_to_string(flags, "none"));		\
     97 	}
     98 
     99 /* SETFLAGS:
    100  * given pflags, additionally set those flags specified in s->st_flags and
    101  * selected by mask (the other flags are left unchanged).
    102  */
    103 #define SETFLAGS(pflags, mask)						\
    104 do {									\
    105 	flags = (s->st_flags & (mask)) | (pflags);			\
    106 	CHANGEFLAGS;							\
    107 } while (0)
    108 
    109 /* CLEARFLAGS:
    110  * given pflags, reset the flags specified in s->st_flags and selected by mask
    111  * (the other flags are left unchanged).
    112  */
    113 #define CLEARFLAGS(pflags, mask)					\
    114 do {									\
    115 	flags = (~(s->st_flags & (mask)) & CH_MASK) & (pflags);		\
    116 	CHANGEFLAGS;							\
    117 } while (0)
    118 #endif	/* HAVE_STRUCT_STAT_ST_FLAGS */
    119 
    120 int
    121 compare(NODE *s, FTSENT *p)
    122 {
    123 	u_int32_t len, val, flags;
    124 	int fd, label;
    125 	const char *cp, *tab;
    126 #if !defined(NO_MD5) || !defined(NO_RMD160) || !defined(NO_SHA1)
    127 	char digestbuf[41];	/* large enough for {MD5,RMD160,SHA1}File() */
    128 #endif
    129 
    130 	tab = NULL;
    131 	label = 0;
    132 	switch(s->type) {
    133 	case F_BLOCK:
    134 		if (!S_ISBLK(p->fts_statp->st_mode))
    135 			goto typeerr;
    136 		break;
    137 	case F_CHAR:
    138 		if (!S_ISCHR(p->fts_statp->st_mode))
    139 			goto typeerr;
    140 		break;
    141 	case F_DIR:
    142 		if (!S_ISDIR(p->fts_statp->st_mode))
    143 			goto typeerr;
    144 		break;
    145 	case F_FIFO:
    146 		if (!S_ISFIFO(p->fts_statp->st_mode))
    147 			goto typeerr;
    148 		break;
    149 	case F_FILE:
    150 		if (!S_ISREG(p->fts_statp->st_mode))
    151 			goto typeerr;
    152 		break;
    153 	case F_LINK:
    154 		if (!S_ISLNK(p->fts_statp->st_mode))
    155 			goto typeerr;
    156 		break;
    157 	case F_SOCK:
    158 		if (!S_ISSOCK(p->fts_statp->st_mode)) {
    159  typeerr:		LABEL;
    160 			printf("\ttype (%s, %s)\n",
    161 			    nodetype(s->type), inotype(p->fts_statp->st_mode));
    162 			return (label);
    163 		}
    164 		break;
    165 	}
    166 	if (Wflag)
    167 		goto afterpermwhack;
    168 #if HAVE_STRUCT_STAT_ST_FLAGS
    169 	if (iflag && !uflag) {
    170 		if (s->flags & F_FLAGS)
    171 		    SETFLAGS(p->fts_statp->st_flags, SP_FLGS);
    172 		return (label);
    173         }
    174 	if (mflag && !uflag) {
    175 		if (s->flags & F_FLAGS)
    176 		    CLEARFLAGS(p->fts_statp->st_flags, SP_FLGS);
    177 		return (label);
    178         }
    179 #endif
    180 	if (s->flags & F_DEV &&
    181 	    (s->type == F_BLOCK || s->type == F_CHAR) &&
    182 	    s->st_rdev != p->fts_statp->st_rdev) {
    183 		LABEL;
    184 		printf("%sdevice (%#x, %#x",
    185 		    tab, s->st_rdev, p->fts_statp->st_rdev);
    186 		if (uflag) {
    187 			if ((unlink(p->fts_accpath) == -1) ||
    188 			    (mknod(p->fts_accpath,
    189 			      s->st_mode | nodetoino(s->type),
    190 			      s->st_rdev) == -1) ||
    191 			    (lchown(p->fts_accpath, p->fts_statp->st_uid,
    192 			      p->fts_statp->st_gid) == -1) )
    193 				printf(", not modified: %s)\n",
    194 				    strerror(errno));
    195 			 else
    196 				printf(", modified)\n");
    197 		} else
    198 			printf(")\n");
    199 		tab = "\t";
    200 	}
    201 	/* Set the uid/gid first, then set the mode. */
    202 	if (s->flags & (F_UID | F_UNAME) && s->st_uid != p->fts_statp->st_uid) {
    203 		LABEL;
    204 		printf("%suser (%lu, %lu",
    205 		    tab, (u_long)s->st_uid, (u_long)p->fts_statp->st_uid);
    206 		if (uflag) {
    207 			if (lchown(p->fts_accpath, s->st_uid, -1))
    208 				printf(", not modified: %s)\n",
    209 				    strerror(errno));
    210 			else
    211 				printf(", modified)\n");
    212 		} else
    213 			printf(")\n");
    214 		tab = "\t";
    215 	}
    216 	if (s->flags & (F_GID | F_GNAME) && s->st_gid != p->fts_statp->st_gid) {
    217 		LABEL;
    218 		printf("%sgid (%lu, %lu",
    219 		    tab, (u_long)s->st_gid, (u_long)p->fts_statp->st_gid);
    220 		if (uflag) {
    221 			if (lchown(p->fts_accpath, -1, s->st_gid))
    222 				printf(", not modified: %s)\n",
    223 				    strerror(errno));
    224 			else
    225 				printf(", modified)\n");
    226 		}
    227 		else
    228 			printf(")\n");
    229 		tab = "\t";
    230 	}
    231 	if (s->flags & F_MODE &&
    232 	    s->st_mode != (p->fts_statp->st_mode & MBITS)) {
    233 		if (lflag) {
    234 			mode_t tmode, mode;
    235 
    236 			tmode = s->st_mode;
    237 			mode = p->fts_statp->st_mode & MBITS;
    238 			/*
    239 			 * if none of the suid/sgid/etc bits are set,
    240 			 * then if the mode is a subset of the target,
    241 			 * skip.
    242 			 */
    243 			if (!((tmode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) ||
    244 			    (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO))))
    245 				if ((mode | tmode) == tmode)
    246 					goto skip;
    247 		}
    248 
    249 		LABEL;
    250 		printf("%spermissions (%#lo, %#lo",
    251 		    tab, (u_long)s->st_mode,
    252 		    (u_long)p->fts_statp->st_mode & MBITS);
    253 		if (uflag) {
    254 			if (lchmod(p->fts_accpath, s->st_mode))
    255 				printf(", not modified: %s)\n",
    256 				    strerror(errno));
    257 			else
    258 				printf(", modified)\n");
    259 		}
    260 		else
    261 			printf(")\n");
    262 		tab = "\t";
    263 	skip:	;
    264 	}
    265 	if (s->flags & F_NLINK && s->type != F_DIR &&
    266 	    s->st_nlink != p->fts_statp->st_nlink) {
    267 		LABEL;
    268 		printf("%slink count (%lu, %lu)\n",
    269 		    tab, (u_long)s->st_nlink, (u_long)p->fts_statp->st_nlink);
    270 		tab = "\t";
    271 	}
    272 	if (s->flags & F_SIZE && s->st_size != p->fts_statp->st_size) {
    273 		LABEL;
    274 		printf("%ssize (%lld, %lld)\n",
    275 		    tab, (long long)s->st_size,
    276 		    (long long)p->fts_statp->st_size);
    277 		tab = "\t";
    278 	}
    279 	/*
    280 	 * XXX
    281 	 * Since utimes(2) only takes a timeval, there's no point in
    282 	 * comparing the low bits of the timespec nanosecond field.  This
    283 	 * will only result in mismatches that we can never fix.
    284 	 *
    285 	 * Doesn't display microsecond differences.
    286 	 */
    287 	if (s->flags & F_TIME) {
    288 		struct timeval tv[2];
    289 		struct stat *ps = p->fts_statp;
    290 		time_t smtime = s->st_mtimespec.tv_sec;
    291 
    292 #ifdef BSD4_4
    293 		time_t pmtime = ps->st_mtimespec.tv_sec;
    294 
    295 		TIMESPEC_TO_TIMEVAL(&tv[0], &s->st_mtimespec);
    296 		TIMESPEC_TO_TIMEVAL(&tv[1], &ps->st_mtimespec);
    297 #else
    298 		time_t pmtime = (time_t)ps->st_mtime;
    299 
    300 		tv[0].tv_sec = smtime;
    301 		tv[0].tv_usec = 0;
    302 		tv[1].tv_sec = pmtime;
    303 		tv[1].tv_usec = 0;
    304 #endif
    305 
    306 		if (tv[0].tv_sec != tv[1].tv_sec ||
    307 		    tv[0].tv_usec != tv[1].tv_usec) {
    308 			LABEL;
    309 			printf("%smodification time (%.24s, ",
    310 			    tab, ctime(&smtime));
    311 			printf("%.24s", ctime(&pmtime));
    312 			if (tflag) {
    313 				tv[1] = tv[0];
    314 				if (utimes(p->fts_accpath, tv))
    315 					printf(", not modified: %s)\n",
    316 					    strerror(errno));
    317 				else
    318 					printf(", modified)\n");
    319 			} else
    320 				printf(")\n");
    321 			tab = "\t";
    322 		}
    323 	}
    324 #if HAVE_STRUCT_STAT_ST_FLAGS
    325 	/*
    326 	 * XXX
    327 	 * since lchflags(2) will reset file times, the utimes() above
    328 	 * may have been useless!  oh well, we'd rather have correct
    329 	 * flags, rather than times?
    330 	 */
    331         if ((s->flags & F_FLAGS) && ((s->st_flags != p->fts_statp->st_flags)
    332 	    || mflag || iflag)) {
    333 		if (s->st_flags != p->fts_statp->st_flags) {
    334 			LABEL;
    335 			printf("%sflags (\"%s\" is not ", tab,
    336 			    flags_to_string(s->st_flags, "none"));
    337 			printf("\"%s\"",
    338 			    flags_to_string(p->fts_statp->st_flags, "none"));
    339 		}
    340 		if (uflag) {
    341 			if (iflag)
    342 				SETFLAGS(0, CH_MASK);
    343 			else if (mflag)
    344 				CLEARFLAGS(0, SP_FLGS);
    345 			else
    346 				SETFLAGS(0, (~SP_FLGS & CH_MASK));
    347 		} else
    348 			printf(")\n");
    349 		tab = "\t";
    350 	}
    351 #endif	/* HAVE_STRUCT_STAT_ST_FLAGS */
    352 
    353 	/*
    354 	 * from this point, no more permission checking or whacking
    355 	 * occurs, only checking of stuff like checksums and symlinks.
    356 	 */
    357  afterpermwhack:
    358 	if (s->flags & F_CKSUM) {
    359 		if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0) {
    360 			LABEL;
    361 			printf("%scksum: %s: %s\n",
    362 			    tab, p->fts_accpath, strerror(errno));
    363 			tab = "\t";
    364 		} else if (crc(fd, &val, &len)) {
    365 			close(fd);
    366 			LABEL;
    367 			printf("%scksum: %s: %s\n",
    368 			    tab, p->fts_accpath, strerror(errno));
    369 			tab = "\t";
    370 		} else {
    371 			close(fd);
    372 			if (s->cksum != val) {
    373 				LABEL;
    374 				printf("%scksum (%lu, %lu)\n",
    375 				    tab, s->cksum, (unsigned long)val);
    376 			}
    377 			tab = "\t";
    378 		}
    379 	}
    380 #ifndef NO_MD5
    381 	if (s->flags & F_MD5) {
    382 		if (MD5File(p->fts_accpath, digestbuf) == NULL) {
    383 			LABEL;
    384 			printf("%smd5: %s: %s\n",
    385 			    tab, p->fts_accpath, strerror(errno));
    386 			tab = "\t";
    387 		} else {
    388 			if (strcmp(s->md5digest, digestbuf)) {
    389 				LABEL;
    390 				printf("%smd5 (0x%s, 0x%s)\n",
    391 				    tab, s->md5digest, digestbuf);
    392 			}
    393 			tab = "\t";
    394 		}
    395 	}
    396 #endif	/* ! NO_MD5 */
    397 #ifndef NO_RMD160
    398 	if (s->flags & F_RMD160) {
    399 		if (RMD160File(p->fts_accpath, digestbuf) == NULL) {
    400 			LABEL;
    401 			printf("%srmd160: %s: %s\n",
    402 			    tab, p->fts_accpath, strerror(errno));
    403 			tab = "\t";
    404 		} else {
    405 			if (strcmp(s->rmd160digest, digestbuf)) {
    406 				LABEL;
    407 				printf("%srmd160 (0x%s, 0x%s)\n",
    408 				    tab, s->rmd160digest, digestbuf);
    409 			}
    410 			tab = "\t";
    411 		}
    412 	}
    413 #endif	/* ! NO_RMD160 */
    414 #ifndef NO_SHA1
    415 	if (s->flags & F_SHA1) {
    416 		if (SHA1File(p->fts_accpath, digestbuf) == NULL) {
    417 			LABEL;
    418 			printf("%ssha1: %s: %s\n",
    419 			    tab, p->fts_accpath, strerror(errno));
    420 			tab = "\t";
    421 		} else {
    422 			if (strcmp(s->sha1digest, digestbuf)) {
    423 				LABEL;
    424 				printf("%ssha1 (0x%s, 0x%s)\n",
    425 				    tab, s->sha1digest, digestbuf);
    426 			}
    427 			tab = "\t";
    428 		}
    429 	}
    430 #endif	/* ! NO_SHA1 */
    431 	if (s->flags & F_SLINK &&
    432 	    strcmp(cp = rlink(p->fts_accpath), s->slink)) {
    433 		LABEL;
    434 		printf("%slink ref (%s, %s", tab, cp, s->slink);
    435 		if (uflag) {
    436 			if ((unlink(p->fts_accpath) == -1) ||
    437 			    (symlink(s->slink, p->fts_accpath) == -1) )
    438 				printf(", not modified: %s)\n",
    439 				    strerror(errno));
    440 			else
    441 				printf(", modified)\n");
    442 		} else
    443 			printf(")\n");
    444 	}
    445 	return (label);
    446 }
    447 
    448 const char *
    449 rlink(const char *name)
    450 {
    451 	static char lbuf[MAXPATHLEN];
    452 	int len;
    453 
    454 	if ((len = readlink(name, lbuf, sizeof(lbuf) - 1)) == -1)
    455 		mtree_err("%s: %s", name, strerror(errno));
    456 	lbuf[len] = '\0';
    457 	return (lbuf);
    458 }
    459