file_cmds/mtree/compare.c

   1 /*-
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #if 0
  31 #ifndef lint
  32 static char sccsid[] = "@(#)compare.c   8.1 (Berkeley) 6/6/93";
  33 #endif /* not lint */
  34 #endif
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD: src/usr.sbin/mtree/compare.c,v 1.34 2005/03/29 11:44:17 tobez Exp $");
  37
  38 #include <CoreFoundation/CoreFoundation.h>
  39 #include <sys/param.h>
  40 #include <sys/stat.h>
  41 #include <sys/time.h>
  42
  43 #include <err.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <fts.h>
  47 #ifndef __APPLE__
  48 #ifdef ENABLE_MD5
  49 #include <md5.h>
  50 #endif
  51 #ifdef ENABLE_RMD160
  52 #include <ripemd.h>
  53 #endif
  54 #ifdef ENABLE_SHA1
  55 #include <sha.h>
  56 #endif
  57 #ifdef ENABLE_SHA256
  58 #include <sha256.h>
  59 #endif
  60 #endif /* !__APPLE__ */
  61 #include <stdint.h>
  62 #include <stdio.h>
  63 #include <time.h>
  64 #include <unistd.h>
  65 #include <vis.h>
  66
  67 #include "metrics.h"
  68 #include "mtree.h"
  69 #include "extern.h"
  70
  71 #ifdef __APPLE__
  72 #include "commoncrypto.h"
  73 #endif /* __APPLE__ */
  74
  75 #define INDENTNAMELEN   8
  76 #define LABEL \
  77         if (!label++) { \
  78                 len = printf("%s changed\n", RP(p)); \
  79                 tab = "\t"; \
  80         }
  81
  82 extern CFMutableDictionaryRef dict;
  83
  84 // max/min times apfs can store on disk
  85 #define APFS_MAX_TIME 0x7fffffffffffffffLL
  86 #define APFS_MIN_TIME (-0x7fffffffffffffffLL-1)
  87
  88 static uint64_t
  89 timespec_to_apfs_timestamp(struct timespec *ts)
  90 {
  91         int64_t total;
  92         int64_t seconds;
  93
  94         // `tv_nsec' can be > one billion, so we split it into two components:
  95         // seconds and actual nanoseconds
  96         // this allows us to detect overflow on the *total* number of nanoseconds
  97         // e.g. if (MAX_SECONDS+2, -2billion) is passed in, we return MAX_SECONDS
  98         seconds = ((int64_t)ts->tv_nsec / (int64_t)NSEC_PER_SEC);
  99
 100         // compute total nanoseconds, checking for overflow:
 101         // seconds = sec + (ns/10e9)
 102         // total = seconds*10e9 + ns%10e9
 103         if (__builtin_saddll_overflow(ts->tv_sec, seconds, &seconds) ||
 104                         __builtin_smulll_overflow(seconds, NSEC_PER_SEC, &total) ||
 105                         __builtin_saddll_overflow(((int64_t)ts->tv_nsec % (int64_t)NSEC_PER_SEC), total, &total)) {
 106                 // checking the sign of "seconds" tells us whether to cap the value at
 107                 // the max or min time
 108                 total = (ts->tv_sec > 0) ? APFS_MAX_TIME : APFS_MIN_TIME;
 109         }
 110
 111         return (uint64_t)total;
 112 }
 113
 114 static void
 115 set_key_value_pair(void *in_key, uint64_t *in_val, bool is_string)
 116 {
 117         CFStringRef key;
 118         CFNumberRef val;
 119
 120         if (is_string) {
 121                 key = CFStringCreateWithCString(NULL, (const char*)in_key, kCFStringEncodingUTF8);
 122
 123         } else {
 124                 key = CFStringCreateWithFormat(NULL, NULL, CFSTR("%llu"), *(uint64_t*)in_key);
 125         }
 126
 127         val = CFNumberCreate(NULL, kCFNumberSInt64Type, in_val);
 128
 129         // we always expect the key to be not present
 130         if (key && val) {
 131                 CFDictionaryAddValue(dict, key, val);
 132         } else {
 133                 if (key) {
 134                         CFRelease(key);
 135                 }
 136                 if (val) {
 137                         CFRelease(val);
 138                 }
 139                 RECORD_FAILURE(1, EINVAL);
 140                 errx(1, "set_key_value_pair: key/value is null");
 141         }
 142
 143         if (key) {
 144                 CFRelease(key);
 145         }
 146         if (val) {
 147                 CFRelease(val);
 148         }
 149 }
 150
 151 int
 152 compare(char *name __unused, NODE *s, FTSENT *p)
 153 {
 154         int error = 0;
 155         struct timeval tv[2];
 156         uint32_t val;
 157         int fd, label;
 158         off_t len;
 159         char *cp;
 160         const char *tab = "";
 161         char *fflags, *badflags;
 162         u_long flags;
 163
 164         label = 0;
 165         switch(s->type) {
 166         case F_BLOCK:
 167                 if (!S_ISBLK(p->fts_statp->st_mode)) {
 168                         RECORD_FAILURE(2, EINVAL);
 169                         goto typeerr;
 170                 }
 171                 break;
 172         case F_CHAR:
 173                 if (!S_ISCHR(p->fts_statp->st_mode)) {
 174                         RECORD_FAILURE(3, EINVAL);
 175                         goto typeerr;
 176                 }
 177                 break;
 178         case F_DIR:
 179                 if (!S_ISDIR(p->fts_statp->st_mode)) {
 180                         RECORD_FAILURE(4, EINVAL);
 181                         goto typeerr;
 182                 }
 183                 break;
 184         case F_FIFO:
 185                 if (!S_ISFIFO(p->fts_statp->st_mode)) {
 186                         RECORD_FAILURE(5, EINVAL);
 187                         goto typeerr;
 188                 }
 189                 break;
 190         case F_FILE:
 191                 if (!S_ISREG(p->fts_statp->st_mode)) {
 192                         RECORD_FAILURE(6, EINVAL);
 193                         goto typeerr;
 194                 }
 195                 break;
 196         case F_LINK:
 197                 if (!S_ISLNK(p->fts_statp->st_mode)) {
 198                         RECORD_FAILURE(7, EINVAL);
 199                         goto typeerr;
 200                 }
 201                 break;
 202         case F_SOCK:
 203                 if (!S_ISSOCK(p->fts_statp->st_mode)) {
 204                         RECORD_FAILURE(8, EINVAL);
 205 typeerr:                LABEL;
 206                         (void)printf("\ttype expected %s found %s\n",
 207                             ftype(s->type), inotype(p->fts_statp->st_mode));
 208                         return (label);
 209                 }
 210                 break;
 211         }
 212         /* Set the uid/gid first, then set the mode. */
 213         if (s->flags & (F_UID | F_UNAME) && s->st_uid != p->fts_statp->st_uid) {
 214                 LABEL;
 215                 (void)printf("%suser expected %lu found %lu",
 216                     tab, (u_long)s->st_uid, (u_long)p->fts_statp->st_uid);
 217                 if (uflag) {
 218                         if (chown(p->fts_accpath, s->st_uid, -1)) {
 219                                 error = errno;
 220                                 RECORD_FAILURE(9, error);
 221                                 (void)printf(" not modified: %s\n",
 222                                     strerror(error));
 223                         } else {
 224                                 (void)printf(" modified\n");
 225                         }
 226                 } else {
 227                         (void)printf("\n");
 228                 }
 229                 tab = "\t";
 230         }
 231         if (s->flags & (F_GID | F_GNAME) && s->st_gid != p->fts_statp->st_gid) {
 232                 LABEL;
 233                 (void)printf("%sgid expected %lu found %lu",
 234                     tab, (u_long)s->st_gid, (u_long)p->fts_statp->st_gid);
 235                 if (uflag) {
 236                         if (chown(p->fts_accpath, -1, s->st_gid)) {
 237                                 error = errno;
 238                                 RECORD_FAILURE(10, error);
 239                                 (void)printf(" not modified: %s\n",
 240                                     strerror(error));
 241                         } else {
 242                                 (void)printf(" modified\n");
 243                         }
 244                 } else {
 245                         (void)printf("\n");
 246                 }
 247                 tab = "\t";
 248         }
 249         if (s->flags & F_MODE &&
 250             !S_ISLNK(p->fts_statp->st_mode) &&
 251             s->st_mode != (p->fts_statp->st_mode & MBITS)) {
 252                 LABEL;
 253                 (void)printf("%spermissions expected %#o found %#o",
 254                     tab, s->st_mode, p->fts_statp->st_mode & MBITS);
 255                 if (uflag) {
 256                         if (chmod(p->fts_accpath, s->st_mode)) {
 257                                 error = errno;
 258                                 RECORD_FAILURE(11, error);
 259                                 (void)printf(" not modified: %s\n",
 260                                     strerror(error));
 261                         } else {
 262                                 (void)printf(" modified\n");
 263                         }
 264                 } else {
 265                         (void)printf("\n");
 266                 }
 267                 tab = "\t";
 268         }
 269         if (s->flags & F_NLINK && s->type != F_DIR &&
 270             s->st_nlink != p->fts_statp->st_nlink) {
 271                 LABEL;
 272                 (void)printf("%slink_count expected %u found %u\n",
 273                     tab, s->st_nlink, p->fts_statp->st_nlink);
 274                 tab = "\t";
 275         }
 276         if (s->flags & F_SIZE && s->st_size != p->fts_statp->st_size &&
 277                 !S_ISDIR(p->fts_statp->st_mode)) {
 278                 LABEL;
 279                 (void)printf("%ssize expected %jd found %jd\n", tab,
 280                     (intmax_t)s->st_size, (intmax_t)p->fts_statp->st_size);
 281                 tab = "\t";
 282         }
 283         if ((s->flags & F_TIME) &&
 284              ((s->st_mtimespec.tv_sec != p->fts_statp->st_mtimespec.tv_sec) ||
 285              (s->st_mtimespec.tv_nsec != p->fts_statp->st_mtimespec.tv_nsec))) {
 286                 if (!mflag) {
 287                         LABEL;
 288                         (void)printf("%smodification time expected %.24s.%09ld ",
 289                                      tab, ctime(&s->st_mtimespec.tv_sec), s->st_mtimespec.tv_nsec);
 290                         (void)printf("found %.24s.%09ld",
 291                                      ctime(&p->fts_statp->st_mtimespec.tv_sec), p->fts_statp->st_mtimespec.tv_nsec);
 292                         if (uflag) {
 293                                 tv[0].tv_sec = s->st_mtimespec.tv_sec;
 294                                 tv[0].tv_usec = s->st_mtimespec.tv_nsec / 1000;
 295                                 tv[1] = tv[0];
 296                                 if (utimes(p->fts_accpath, tv)) {
 297                                         error = errno;
 298                                         RECORD_FAILURE(12, error);
 299                                         (void)printf(" not modified: %s\n",
 300                                                      strerror(error));
 301                                 } else {
 302                                         (void)printf(" modified\n");
 303                                 }
 304                         } else {
 305                                 (void)printf("\n");
 306                         }
 307                         tab = "\t";
 308                 }
 309                 if (!insert_mod && mflag) {
 310                         uint64_t s_mod_time = timespec_to_apfs_timestamp(&s->st_mtimespec);
 311                         char *mod_string = "MODIFICATION";
 312                         set_key_value_pair(mod_string, &s_mod_time, true);
 313                         insert_mod = 1;
 314                 }
 315         }
 316         if (s->flags & F_CKSUM) {
 317                 if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0) {
 318                         LABEL;
 319                         error = errno;
 320                         RECORD_FAILURE(13, error);
 321                         (void)printf("%scksum: %s: %s\n",
 322                             tab, p->fts_accpath, strerror(error));
 323                         tab = "\t";
 324                 } else if (crc(fd, &val, &len)) {
 325                         (void)close(fd);
 326                         LABEL;
 327                         error = errno;
 328                         RECORD_FAILURE(14, error);
 329                         (void)printf("%scksum: %s: %s\n",
 330                             tab, p->fts_accpath, strerror(error));
 331                         tab = "\t";
 332                 } else {
 333                         (void)close(fd);
 334                         if (s->cksum != val) {
 335                                 LABEL;
 336                                 (void)printf("%scksum expected %lu found %lu\n",
 337                                     tab, s->cksum, (unsigned long)val);
 338                                 tab = "\t";
 339                         }
 340                 }
 341         }
 342         if (s->flags & F_FLAGS) {
 343                 // There are unpublished flags that should not fail comparison
 344                 // we convert to string and back to filter them out
 345                 fflags = badflags = flags_to_string(p->fts_statp->st_flags);
 346                 if (strcmp("none", fflags) == 0) {
 347                         flags = 0;
 348                 } else if (strtofflags(&badflags, &flags, NULL) != 0)
 349                         errx(1, "invalid flag %s", badflags);
 350                 free(fflags);
 351                 if (s->st_flags != flags) {
 352                         LABEL;
 353                         fflags = flags_to_string(s->st_flags);
 354                         (void)printf("%sflags expected \"%s\"", tab, fflags);
 355                         free(fflags);
 356
 357                         fflags = flags_to_string(flags);
 358                         (void)printf(" found \"%s\"", fflags);
 359                         free(fflags);
 360
 361                         if (uflag) {
 362                                 if (chflags(p->fts_accpath, (u_int)s->st_flags)) {
 363                                         error = errno;
 364                                         RECORD_FAILURE(15, error);
 365                                         (void)printf(" not modified: %s\n",
 366                                                      strerror(error));
 367                                 } else {
 368                                         (void)printf(" modified\n");
 369                                 }
 370                         } else {
 371                                 (void)printf("\n");
 372                         }
 373                         tab = "\t";
 374                 }
 375         }
 376 #ifdef ENABLE_MD5
 377         if (s->flags & F_MD5) {
 378                 char *new_digest, buf[33];
 379 #ifdef __clang__
 380 /* clang doesn't like MD5 due to security concerns, but it's used for file data/metadata integrity.. */
 381 #pragma clang diagnostic push
 382 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 383                 new_digest = MD5File(p->fts_accpath, buf);
 384 #pragma clang diagnostic pop
 385 #endif
 386                 if (!new_digest) {
 387                         LABEL;
 388                         error = errno;
 389                         RECORD_FAILURE(16, error);
 390                         printf("%sMD5: %s: %s\n", tab, p->fts_accpath,
 391                                strerror(error));
 392                         tab = "\t";
 393                 } else if (strcmp(new_digest, s->md5digest)) {
 394                         LABEL;
 395                         printf("%sMD5 expected %s found %s\n", tab, s->md5digest,
 396                                new_digest);
 397                         tab = "\t";
 398                 }
 399         }
 400 #endif /* ENABLE_MD5 */
 401 #ifdef ENABLE_SHA1
 402         if (s->flags & F_SHA1) {
 403                 char *new_digest, buf[41];
 404 #ifdef __clang__
 405 /* clang doesn't like SHA1 due to security concerns, but it's used for file data/metadata integrity.. */
 406 #pragma clang diagnostic push
 407 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 408                 new_digest = SHA1_File(p->fts_accpath, buf);
 409 #pragma clang diagnostic pop
 410 #endif
 411                 if (!new_digest) {
 412                         LABEL;
 413                         error = errno;
 414                         RECORD_FAILURE(17, error);
 415                         printf("%sSHA-1: %s: %s\n", tab, p->fts_accpath,
 416                                strerror(error));
 417                         tab = "\t";
 418                 } else if (strcmp(new_digest, s->sha1digest)) {
 419                         LABEL;
 420                         printf("%sSHA-1 expected %s found %s\n",
 421                                tab, s->sha1digest, new_digest);
 422                         tab = "\t";
 423                 }
 424         }
 425 #endif /* ENABLE_SHA1 */
 426 #ifdef ENABLE_RMD160
 427         if (s->flags & F_RMD160) {
 428                 char *new_digest, buf[41];
 429 #ifdef __clang__
 430 /* clang doesn't like RIPEMD160 due to security concerns, but it's used for file data/metadata integrity.. */
 431 #pragma clang diagnostic push
 432 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 433                 new_digest = RIPEMD160_File(p->fts_accpath, buf);
 434 #pragma clang diagnostic pop
 435 #endif
 436                 if (!new_digest) {
 437                         LABEL;
 438                         error = errno;
 439                         RECORD_FAILURE(18, error);
 440                         printf("%sRIPEMD160: %s: %s\n", tab,
 441                                p->fts_accpath, strerror(error));
 442                         tab = "\t";
 443                 } else if (strcmp(new_digest, s->rmd160digest)) {
 444                         LABEL;
 445                         printf("%sRIPEMD160 expected %s found %s\n",
 446                                tab, s->rmd160digest, new_digest);
 447                         tab = "\t";
 448                 }
 449         }
 450 #endif /* ENABLE_RMD160 */
 451 #ifdef ENABLE_SHA256
 452         if (s->flags & F_SHA256) {
 453                 char *new_digest, buf[kSHA256NullTerminatedBuffLen];
 454
 455                 new_digest = SHA256_File(p->fts_accpath, buf);
 456                 if (!new_digest) {
 457                         LABEL;
 458                         error = errno;
 459                         RECORD_FAILURE(19, error);
 460                         printf("%sSHA-256: %s: %s\n", tab, p->fts_accpath,
 461                                strerror(error));
 462                         tab = "\t";
 463                 } else if (strcmp(new_digest, s->sha256digest)) {
 464                         LABEL;
 465                         printf("%sSHA-256 expected %s found %s\n",
 466                                tab, s->sha256digest, new_digest);
 467                         tab = "\t";
 468                 }
 469         }
 470 #endif /* ENABLE_SHA256 */
 471
 472         if (s->flags & F_SLINK &&
 473             strcmp(cp = rlink(p->fts_accpath), s->slink)) {
 474                 LABEL;
 475                 (void)printf("%slink_ref expected %s found %s\n",
 476                       tab, s->slink, cp);
 477         }
 478         if ((s->flags & F_BTIME) &&
 479             ((s->st_birthtimespec.tv_sec != p->fts_statp->st_birthtimespec.tv_sec) ||
 480              (s->st_birthtimespec.tv_nsec != p->fts_statp->st_birthtimespec.tv_nsec))) {
 481                     if (!mflag) {
 482                             LABEL;
 483                             (void)printf("%sbirth time expected %.24s.%09ld ",
 484                                          tab, ctime(&s->st_birthtimespec.tv_sec), s->st_birthtimespec.tv_nsec);
 485                             (void)printf("found %.24s.%09ld\n",
 486                                          ctime(&p->fts_statp->st_birthtimespec.tv_sec), p->fts_statp->st_birthtimespec.tv_nsec);
 487                             tab = "\t";
 488                     }
 489                     if (!insert_birth && mflag) {
 490                             uint64_t s_create_time = timespec_to_apfs_timestamp(&s->st_birthtimespec);
 491                             char *birth_string = "BIRTH";
 492                             set_key_value_pair(birth_string, &s_create_time, true);
 493                             insert_birth = 1;
 494                     }
 495             }
 496         if ((s->flags & F_ATIME) &&
 497             ((s->st_atimespec.tv_sec != p->fts_statp->st_atimespec.tv_sec) ||
 498              (s->st_atimespec.tv_nsec != p->fts_statp->st_atimespec.tv_nsec))) {
 499                     if (!mflag) {
 500                             LABEL;
 501                             (void)printf("%saccess time expected %.24s.%09ld ",
 502                                          tab, ctime(&s->st_atimespec.tv_sec), s->st_atimespec.tv_nsec);
 503                             (void)printf("found %.24s.%09ld\n",
 504                                          ctime(&p->fts_statp->st_atimespec.tv_sec), p->fts_statp->st_atimespec.tv_nsec);
 505                             tab = "\t";
 506                     }
 507                     if (!insert_access && mflag) {
 508                             uint64_t s_access_time = timespec_to_apfs_timestamp(&s->st_atimespec);
 509                             char *access_string = "ACCESS";
 510                             set_key_value_pair(access_string, &s_access_time, true);
 511                             insert_access = 1;
 512
 513                     }
 514             }
 515         if ((s->flags & F_CTIME) &&
 516             ((s->st_ctimespec.tv_sec != p->fts_statp->st_ctimespec.tv_sec) ||
 517              (s->st_ctimespec.tv_nsec != p->fts_statp->st_ctimespec.tv_nsec))) {
 518                     if (!mflag) {
 519                             LABEL;
 520                             (void)printf("%smetadata modification time expected %.24s.%09ld ",
 521                                          tab, ctime(&s->st_ctimespec.tv_sec), s->st_ctimespec.tv_nsec);
 522                             (void)printf("found %.24s.%09ld\n",
 523                                          ctime(&p->fts_statp->st_ctimespec.tv_sec), p->fts_statp->st_ctimespec.tv_nsec);
 524                             tab = "\t";
 525                     }
 526                     if (!insert_change && mflag) {
 527                             uint64_t s_mod_time = timespec_to_apfs_timestamp(&s->st_ctimespec);
 528                             char *change_string = "CHANGE";
 529                             set_key_value_pair(change_string, &s_mod_time, true);
 530                             insert_change = 1;
 531                     }
 532             }
 533         if (s->flags & F_PTIME) {
 534                 int supported;
 535                 struct timespec ptimespec = ptime(p->fts_accpath, &supported);
 536                 if (!supported) {
 537                         LABEL;
 538                         (void)printf("%stime added to parent folder expected %.24s.%09ld found that it is not supported\n",
 539                                         tab, ctime(&s->st_ptimespec.tv_sec), s->st_ptimespec.tv_nsec);
 540                         tab = "\t";
 541                 } else if (supported && ((s->st_ptimespec.tv_sec != ptimespec.tv_sec) ||
 542                            (s->st_ptimespec.tv_nsec != ptimespec.tv_nsec))) {
 543                         if (!mflag) {
 544                                 LABEL;
 545                                 (void)printf("%stime added to parent folder expected %.24s.%09ld ",
 546                                               tab, ctime(&s->st_ptimespec.tv_sec), s->st_ptimespec.tv_nsec);
 547                                 (void)printf("found %.24s.%09ld\n",
 548                                               ctime(&ptimespec.tv_sec), ptimespec.tv_nsec);
 549                                 tab = "\t";
 550                         } else if (!insert_parent && mflag) {
 551                                 uint64_t s_added_time = timespec_to_apfs_timestamp(&s->st_ptimespec);
 552                                 char *added_string = "DATEADDED";
 553                                 set_key_value_pair(added_string, &s_added_time, true);
 554                                 insert_parent = 1;
 555                         }
 556                 }
 557         }
 558         if (s->flags & F_XATTRS) {
 559                 char buf[kSHA256NullTerminatedBuffLen];
 560                 xattr_info *ai;
 561                 ai = SHA256_Path_XATTRs(p->fts_accpath, buf);
 562                 if (!mflag) {
 563                         if (ai && !ai->digest) {
 564                                 LABEL;
 565                                 printf("%sxattrsdigest missing, expected: %s\n", tab, s->xattrsdigest);
 566                                 tab = "\t";
 567                         } else if (ai && strcmp(ai->digest, s->xattrsdigest)) {
 568                                 LABEL;
 569                                 printf("%sxattrsdigest expected %s found %s\n",
 570                                        tab, s->xattrsdigest, ai->digest);
 571                                 tab = "\t";
 572                         }
 573                 }
 574                 if (mflag) {
 575                         if (ai && ai->xdstream_priv_id != s->xdstream_priv_id) {
 576                                 set_key_value_pair((void*)&ai->xdstream_priv_id, &s->xdstream_priv_id, false);
 577                         }
 578                 }
 579                 free(ai);
 580         }
 581         if ((s->flags & F_INODE) &&
 582             (p->fts_statp->st_ino != s->st_ino)) {
 583                 if (!mflag) {
 584                         LABEL;
 585                         (void)printf("%sinode expected %llu found %llu\n",
 586                                      tab, s->st_ino, p->fts_statp->st_ino);
 587                         tab = "\t";
 588                 }
 589                 if (mflag) {
 590                         set_key_value_pair((void*)&p->fts_statp->st_ino, &s->st_ino, false);
 591                 }
 592         }
 593         if (s->flags & F_ACL) {
 594                 char *new_digest, buf[kSHA256NullTerminatedBuffLen];
 595                 new_digest = SHA256_Path_ACL(p->fts_accpath, buf);
 596                 if (!new_digest) {
 597                         LABEL;
 598                         printf("%sacldigest missing, expected: %s\n", tab, s->acldigest);
 599                         tab = "\t";
 600                 } else if (strcmp(new_digest, s->acldigest)) {
 601                         LABEL;
 602                         printf("%sacldigest expected %s found %s\n",
 603                                tab, s->acldigest, new_digest);
 604                         tab = "\t";
 605                 }
 606         }
 607         if (s->flags & F_SIBLINGID) {
 608                 uint64_t new_sibling_id = get_sibling_id(p->fts_accpath);
 609                 new_sibling_id = (new_sibling_id != p->fts_statp->st_ino) ? new_sibling_id : 0;
 610                 if (new_sibling_id != s->sibling_id) {
 611                         if (!mflag) {
 612                                 LABEL;
 613                                 (void)printf("%ssibling id expected %llu found %llu\n",
 614                                              tab, s->sibling_id, new_sibling_id);
 615                                 tab = "\t";
 616                         }
 617                         if (mflag) {
 618                                 set_key_value_pair((void*)&new_sibling_id, &s->sibling_id, false);
 619                         }
 620                 }
 621         }
 622
 623         return (label);
 624 }
 625
 626 const char *
 627 inotype(u_int type)
 628 {
 629         switch(type & S_IFMT) {
 630         case S_IFBLK:
 631                 return ("block");
 632         case S_IFCHR:
 633                 return ("char");
 634         case S_IFDIR:
 635                 return ("dir");
 636         case S_IFIFO:
 637                 return ("fifo");
 638         case S_IFREG:
 639                 return ("file");
 640         case S_IFLNK:
 641                 return ("link");
 642         case S_IFSOCK:
 643                 return ("socket");
 644         default:
 645                 return ("unknown");
 646         }
 647         /* NOTREACHED */
 648 }
 649
 650 const char *
 651 ftype(u_int type)
 652 {
 653         switch(type) {
 654         case F_BLOCK:
 655                 return ("block");
 656         case F_CHAR:
 657                 return ("char");
 658         case F_DIR:
 659                 return ("dir");
 660         case F_FIFO:
 661                 return ("fifo");
 662         case F_FILE:
 663                 return ("file");
 664         case F_LINK:
 665                 return ("link");
 666         case F_SOCK:
 667                 return ("socket");
 668         default:
 669                 return ("unknown");
 670         }
 671         /* NOTREACHED */
 672 }
 673
 674 char *
 675 rlink(char *name)
 676 {
 677         int error = 0;
 678         static char lbuf[MAXPATHLEN];
 679         ssize_t len;
 680
 681         if ((len = readlink(name, lbuf, sizeof(lbuf) - 1)) == -1) {
 682                 error = errno;
 683                 RECORD_FAILURE(20, error);
 684                 errc(1, error, "line %d: %s", lineno, name);
 685         }
 686         lbuf[len] = '\0';
 687         return (lbuf);
 688 }