usr.sbin/mtree/compare.c

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