src/fssum.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2012 STRATO AG.  All rights reserved.
   4  */
   5 #ifdef __linux__
   6 #define _BSD_SOURCE
   7 #define _DEFAULT_SOURCE
   8 #define _LARGEFILE64_SOURCE
   9 #ifndef _GNU_SOURCE
  10 #define _GNU_SOURCE
  11 #endif
  12 #endif
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <fcntl.h>
  18 #include <dirent.h>
  19 #include <errno.h>
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <sys/sysmacros.h>
  23 #include <sys/xattr.h>
  24 #ifdef __SOLARIS__
  25 #include <sys/mkdev.h>
  26 #endif
  27 #include "md5.h"
  28 #include <netinet/in.h>
  29 #include <inttypes.h>
  30 #include <assert.h>
  31 #include <endian.h>
  32
  33 #define CS_SIZE 16
  34 #define CHUNKS  128
  35
  36 #ifdef __linux__
  37 #ifndef SEEK_DATA
  38 #define SEEK_DATA 3
  39 #define SEEK_HOLE 4
  40 #endif
  41 #endif
  42
  43 /* TODO: add hardlink recognition */
  44
  45 struct excludes {
  46         char *path;
  47         int len;
  48 };
  49
  50 typedef struct _sum {
  51         MD5_CTX         md5;
  52         unsigned char   out[16];
  53 } sum_t;
  54
  55 typedef int (*sum_file_data_t)(int fd, sum_t *dst);
  56
  57 int gen_manifest = 0;
  58 int in_manifest = 0;
  59 char *checksum = NULL;
  60 struct excludes *excludes;
  61 int n_excludes = 0;
  62 int verbose = 0;
  63 FILE *out_fp;
  64 FILE *in_fp;
  65
  66 enum _flags {
  67         FLAG_UID,
  68         FLAG_GID,
  69         FLAG_MODE,
  70         FLAG_ATIME,
  71         FLAG_MTIME,
  72         FLAG_CTIME,
  73         FLAG_DATA,
  74         FLAG_XATTRS,
  75         FLAG_OPEN_ERROR,
  76         FLAG_STRUCTURE,
  77         NUM_FLAGS
  78 };
  79
  80 const char flchar[] = "ugoamcdtes";
  81 char line[65536];
  82
  83 int flags[NUM_FLAGS] = {1, 1, 1, 1, 1, 0, 1, 1, 0, 0};
  84
  85 char *
  86 getln(char *buf, int size, FILE *fp)
  87 {
  88         char *p;
  89         int l;
  90
  91         p = fgets(buf, size, fp);
  92         if (!p)
  93                 return NULL;
  94
  95         l = strlen(p);
  96         while(l > 0  && (p[l - 1] == '\n' || p[l - 1] == '\r'))
  97                 p[--l] = 0;
  98
  99         return p;
 100 }
 101
 102 void
 103 parse_flag(int c)
 104 {
 105         int i;
 106         int is_upper = 0;
 107
 108         if (c >= 'A' && c <= 'Z') {
 109                 is_upper = 1;
 110                 c += 'a' - 'A';
 111         }
 112         for (i = 0; flchar[i]; ++i) {
 113                 if (flchar[i] == c) {
 114                         flags[i] = is_upper ? 0 : 1;
 115                         return;
 116                 }
 117         }
 118         fprintf(stderr, "unrecognized flag %c\n", c);
 119         exit(-1);
 120 }
 121
 122 void
 123 parse_flags(char *p)
 124 {
 125         while (*p)
 126                 parse_flag(*p++);
 127 }
 128
 129 void
 130 usage(void)
 131 {
 132         fprintf(stderr, "usage: fssum <options> <path>\n");
 133         fprintf(stderr, "  options:\n");
 134         fprintf(stderr, "    -f           : write out a full manifest file\n");
 135         fprintf(stderr, "    -w <file>    : send output to file\n");
 136         fprintf(stderr, "    -v           : verbose mode (debugging only)\n");
 137         fprintf(stderr, "    -r <file>    : read checksum or manifest from file\n");
 138         fprintf(stderr, "    -[ugoamcdtes]: specify which fields to include in checksum calculation.\n");
 139         fprintf(stderr, "         u       : include uid\n");
 140         fprintf(stderr, "         g       : include gid\n");
 141         fprintf(stderr, "         o       : include mode\n");
 142         fprintf(stderr, "         m       : include mtime\n");
 143         fprintf(stderr, "         a       : include atime\n");
 144         fprintf(stderr, "         c       : include ctime\n");
 145         fprintf(stderr, "         d       : include file data\n");
 146         fprintf(stderr, "         t       : include xattrs\n");
 147         fprintf(stderr, "         e       : include open errors (aborts otherwise)\n");
 148         fprintf(stderr, "         s       : include block structure (holes)\n");
 149         fprintf(stderr, "    -[UGOAMCDTES]: exclude respective field from calculation\n");
 150         fprintf(stderr, "    -n           : reset all flags\n");
 151         fprintf(stderr, "    -N           : set all flags\n");
 152         fprintf(stderr, "    -x path      : exclude path when building checksum (multiple ok)\n");
 153         fprintf(stderr, "    -h           : this help\n\n");
 154         fprintf(stderr, "The default field mask is ugoamCdtES. If the checksum/manifest is read from a\n");
 155         fprintf(stderr, "file, the mask is taken from there and the values given on the command line\n");
 156         fprintf(stderr, "are ignored.\n");
 157         exit(-1);
 158 }
 159
 160 static char buf[65536];
 161
 162 void *
 163 alloc(size_t sz)
 164 {
 165         void *p = malloc(sz);
 166
 167         if (!p) {
 168                 fprintf(stderr, "malloc failed\n");
 169                 exit(-1);
 170         }
 171
 172         return p;
 173 }
 174
 175 void
 176 sum_init(sum_t *cs)
 177 {
 178         MD5_Init(&cs->md5);
 179 }
 180
 181 void
 182 sum_fini(sum_t *cs)
 183 {
 184         MD5_Final(cs->out, &cs->md5);
 185 }
 186
 187 void
 188 sum_add(sum_t *cs, void *buf, int size)
 189 {
 190         MD5_Update(&cs->md5, buf, size);
 191 }
 192
 193 void
 194 sum_add_sum(sum_t *dst, sum_t *src)
 195 {
 196         sum_add(dst, src->out, sizeof(src->out));
 197 }
 198
 199 void
 200 sum_add_u64(sum_t *dst, uint64_t val)
 201 {
 202         uint64_t v = htobe64(val);
 203         sum_add(dst, &v, sizeof(v));
 204 }
 205
 206 void
 207 sum_add_time(sum_t *dst, time_t t)
 208 {
 209         sum_add_u64(dst, t);
 210 }
 211
 212 char *
 213 sum_to_string(sum_t *dst)
 214 {
 215         int i;
 216         char *s = alloc(CS_SIZE * 2 + 1);
 217
 218         for (i = 0; i < CS_SIZE; ++i)
 219                 sprintf(s + i * 2, "%02x", dst->out[i]);
 220
 221         return s;
 222 }
 223
 224 int
 225 namecmp(const void *aa, const void *bb)
 226 {
 227         char * const *a = aa;
 228         char * const *b = bb;
 229
 230         return strcmp(*a, *b);
 231 }
 232
 233 int
 234 sum_xattrs(int fd, sum_t *dst)
 235 {
 236         ssize_t buflen;
 237         ssize_t len;
 238         char *buf;
 239         char *p;
 240         char **names = NULL;
 241         int num_xattrs = 0;
 242         int ret = 0;
 243         int i;
 244
 245         buflen = flistxattr(fd, NULL, 0);
 246         if (buflen < 0)
 247                 return -errno;
 248         /* no xattrs exist */
 249         if (buflen == 0)
 250                 return 0;
 251
 252         buf = malloc(buflen);
 253         if (!buf)
 254                 return -ENOMEM;
 255
 256         buflen = flistxattr(fd, buf, buflen);
 257         if (buflen < 0) {
 258                 ret = -errno;
 259                 goto out;
 260         }
 261
 262         /*
 263          * Keep the list of xattrs sorted, because the order in which they are
 264          * listed is filesystem dependent, so we want to get the same checksum
 265          * on different filesystems.
 266          */
 267
 268         p = buf;
 269         len = buflen;
 270         while (len > 0) {
 271                 int keylen;
 272
 273                 keylen = strlen(p) + 1; /* +1 for NULL terminator */
 274                 len -= keylen;
 275                 p += keylen;
 276                 num_xattrs++;
 277         }
 278
 279         names = malloc(sizeof(char *) * num_xattrs);
 280         if (!names) {
 281                 ret = -ENOMEM;
 282                 goto out;
 283         }
 284
 285         p = buf;
 286         for (i = 0; i < num_xattrs; i++) {
 287                 names[i] = p;
 288                 p += strlen(p) + 1; /* +1 for NULL terminator */
 289         }
 290
 291         qsort(names, num_xattrs, sizeof(char *), namecmp);
 292
 293         for (i = 0; i < num_xattrs; i++) {
 294                 len = fgetxattr(fd, names[i], NULL, 0);
 295                 if (len < 0) {
 296                         ret = -errno;
 297                         goto out;
 298                 }
 299                 sum_add(dst, names[i], strlen(names[i]));
 300                 /* no value */
 301                 if (len == 0)
 302                         continue;
 303                 p = malloc(len);
 304                 if (!p) {
 305                         ret = -ENOMEM;
 306                         goto out;
 307                 }
 308                 len = fgetxattr(fd, names[i], p, len);
 309                 if (len < 0) {
 310                         ret = -errno;
 311                         free(p);
 312                         goto out;
 313                 }
 314                 sum_add(dst, p, len);
 315                 free(p);
 316         }
 317 out:
 318         free(buf);
 319         free(names);
 320
 321         return ret;
 322 }
 323
 324 int
 325 sum_file_data_permissive(int fd, sum_t *dst)
 326 {
 327         int ret;
 328
 329         while (1) {
 330                 ret = read(fd, buf, sizeof(buf));
 331                 if (ret < 0)
 332                         return -errno;
 333                 sum_add(dst, buf, ret);
 334                 if (ret < sizeof(buf))
 335                         break;
 336         }
 337         return 0;
 338 }
 339
 340 int
 341 sum_file_data_strict(int fd, sum_t *dst)
 342 {
 343         int ret;
 344         off_t pos;
 345
 346         pos = lseek(fd, 0, SEEK_CUR);
 347         if (pos == (off_t)-1)
 348                 return errno == ENXIO ? 0 : -2;
 349
 350         while (1) {
 351                 pos = lseek(fd, pos, SEEK_DATA);
 352                 if (pos == (off_t)-1)
 353                         return errno == ENXIO ? 0 : -2;
 354                 ret = read(fd, buf, sizeof(buf));
 355                 assert(ret); /* eof found by lseek */
 356                 if (ret <= 0)
 357                         return ret;
 358                 if (verbose >= 2)
 359                         fprintf(stderr,
 360                                 "adding to sum at file offset %llu, %d bytes\n",
 361                                 (unsigned long long)pos, ret);
 362                 sum_add_u64(dst, (uint64_t)pos);
 363                 sum_add(dst, buf, ret);
 364                 pos += ret;
 365         }
 366 }
 367
 368 char *
 369 escape(char *in)
 370 {
 371         char *out = alloc(strlen(in) * 3 + 1);
 372         char *src = in;
 373         char *dst = out;
 374
 375         for (; *src; ++src) {
 376                 if (*src >= 32 && *src < 127 && *src != '\\') {
 377                         *dst++ = *src;
 378                 } else {
 379                         sprintf(dst, "\\%02x", (unsigned char)*src);
 380                         dst += 3;
 381                 }
 382         }
 383         *dst = 0;
 384
 385         return out;
 386 }
 387
 388 void
 389 excess_file(const char *fn)
 390 {
 391         printf("only in local fs: %s\n", fn);
 392 }
 393
 394 void
 395 missing_file(const char *fn)
 396 {
 397         printf("only in remote fs: %s\n", fn);
 398 }
 399
 400 int
 401 pathcmp(const char *a, const char *b)
 402 {
 403         int len_a = strlen(a);
 404         int len_b = strlen(b);
 405
 406         /*
 407          * as the containing directory is sent after the files, it has to
 408          * come out bigger in the comparison.
 409          */
 410         if (len_a < len_b && a[len_a - 1] == '/' && strncmp(a, b, len_a) == 0)
 411                 return 1;
 412         if (len_a > len_b && b[len_b - 1] == '/' && strncmp(a, b, len_b) == 0)
 413                 return -1;
 414
 415         return strcmp(a, b);
 416 }
 417
 418 void
 419 check_match(char *fn, char *local_m, char *remote_m,
 420             char *local_c, char *remote_c)
 421 {
 422         int match_m = !strcmp(local_m, remote_m);
 423         int match_c = !strcmp(local_c, remote_c);
 424
 425         if (match_m && !match_c) {
 426                 printf("data mismatch in %s\n", fn);
 427         } else if (!match_m && match_c) {
 428                 printf("metadata mismatch in %s\n", fn);
 429         } else if (!match_m && !match_c) {
 430                 printf("metadata and data mismatch in %s\n", fn);
 431         }
 432 }
 433
 434 char *prev_fn;
 435 char *prev_m;
 436 char *prev_c;
 437 void
 438 check_manifest(char *fn, char *m, char *c, int last_call)
 439 {
 440         char *rem_m;
 441         char *rem_c;
 442         char *l;
 443         int cmp;
 444
 445         if (prev_fn) {
 446                 if (last_call)
 447                         cmp = -1;
 448                 else
 449                         cmp = pathcmp(prev_fn, fn);
 450                 if (cmp > 0) {
 451                         excess_file(fn);
 452                         return;
 453                 } else if (cmp < 0) {
 454                         missing_file(prev_fn);
 455                 } else {
 456                         check_match(fn, m, prev_m, c, prev_c);
 457                 }
 458                 free(prev_fn);
 459                 free(prev_m);
 460                 free(prev_c);
 461                 prev_fn = NULL;
 462                 prev_m = NULL;
 463                 prev_c = NULL;
 464                 if (cmp == 0)
 465                         return;
 466         }
 467         while ((l = getln(line, sizeof(line), in_fp))) {
 468                 rem_c = strrchr(l, ' ');
 469                 if (!rem_c) {
 470                         /* final cs */
 471                         checksum = strdup(l);
 472                         break;
 473                 }
 474                 if (rem_c == l) {
 475 malformed:
 476                         fprintf(stderr, "malformed input\n");
 477                         exit(-1);
 478                 }
 479                 *rem_c++ = 0;
 480                 rem_m = strrchr(l, ' ');
 481                 if (!rem_m)
 482                         goto malformed;
 483                 *rem_m++ = 0;
 484
 485                 if (last_call)
 486                         cmp = -1;
 487                 else
 488                         cmp = pathcmp(l, fn);
 489                 if (cmp == 0) {
 490                         check_match(fn, m, rem_m, c, rem_c);
 491                         return;
 492                 } else if (cmp > 0) {
 493                         excess_file(fn);
 494                         prev_fn = strdup(l);
 495                         prev_m = strdup(rem_m);
 496                         prev_c = strdup(rem_c);
 497                         return;
 498                 }
 499                 missing_file(l);
 500         }
 501         if (!last_call)
 502                 excess_file(fn);
 503 }
 504
 505 void
 506 sum(int dirfd, int level, sum_t *dircs, char *path_prefix, char *path_in)
 507 {
 508         DIR *d;
 509         struct dirent *de;
 510         char **namelist = NULL;
 511         int alloclen = 0;
 512         int entries = 0;
 513         int i;
 514         int ret;
 515         int fd;
 516         int excl;
 517         sum_file_data_t sum_file_data = flags[FLAG_STRUCTURE] ?
 518                         sum_file_data_strict : sum_file_data_permissive;
 519         struct stat64 dir_st;
 520
 521         if (fstat64(dirfd, &dir_st)) {
 522                 perror("fstat");
 523                 exit(-1);
 524         }
 525
 526         d = fdopendir(dirfd);
 527         if (!d) {
 528                 perror("opendir");
 529                 exit(-1);
 530         }
 531         while((de = readdir(d))) {
 532                 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
 533                         continue;
 534                 if (entries == alloclen) {
 535                         alloclen += CHUNKS;
 536                         namelist = realloc(namelist,
 537                                            alloclen * sizeof(*namelist));
 538                         if (!namelist) {
 539                                 fprintf(stderr, "malloc failed\n");
 540                                 exit(-1);
 541                         }
 542                 }
 543                 namelist[entries] = strdup(de->d_name);
 544                 if (!namelist[entries]) {
 545                         fprintf(stderr, "malloc failed\n");
 546                         exit(-1);
 547                 }
 548                 ++entries;
 549         }
 550         qsort(namelist, entries, sizeof(*namelist), namecmp);
 551         for (i = 0; i < entries; ++i) {
 552                 struct stat64 st;
 553                 sum_t cs;
 554                 sum_t meta;
 555                 char *path;
 556
 557                 sum_init(&cs);
 558                 sum_init(&meta);
 559                 path = alloc(strlen(path_in) + strlen(namelist[i]) + 3);
 560                 sprintf(path, "%s/%s", path_in, namelist[i]);
 561                 for (excl = 0; excl < n_excludes; ++excl) {
 562                         if (strncmp(excludes[excl].path, path,
 563                             excludes[excl].len) == 0)
 564                                 goto next;
 565                 }
 566
 567                 ret = fchdir(dirfd);
 568                 if (ret == -1) {
 569                         perror("fchdir");
 570                         exit(-1);
 571                 }
 572                 ret = lstat64(namelist[i], &st);
 573                 if (ret) {
 574                         fprintf(stderr, "stat failed for %s/%s: %s\n",
 575                                 path_prefix, path, strerror(errno));
 576                         exit(-1);
 577                 }
 578
 579                 /* We are crossing into a different subvol, skip this subtree. */
 580                 if (st.st_dev != dir_st.st_dev)
 581                         goto next;
 582
 583                 sum_add_u64(&meta, level);
 584                 sum_add(&meta, namelist[i], strlen(namelist[i]));
 585                 if (!S_ISDIR(st.st_mode))
 586                         sum_add_u64(&meta, st.st_nlink);
 587                 if (flags[FLAG_UID])
 588                         sum_add_u64(&meta, st.st_uid);
 589                 if (flags[FLAG_GID])
 590                         sum_add_u64(&meta, st.st_gid);
 591                 if (flags[FLAG_MODE])
 592                         sum_add_u64(&meta, st.st_mode);
 593                 if (flags[FLAG_ATIME])
 594                         sum_add_time(&meta, st.st_atime);
 595                 if (flags[FLAG_MTIME])
 596                         sum_add_time(&meta, st.st_mtime);
 597                 if (flags[FLAG_CTIME])
 598                         sum_add_time(&meta, st.st_ctime);
 599                 if (flags[FLAG_XATTRS] &&
 600                     (S_ISDIR(st.st_mode) || S_ISREG(st.st_mode))) {
 601                         fd = openat(dirfd, namelist[i], 0);
 602                         if (fd == -1 && flags[FLAG_OPEN_ERROR]) {
 603                                 sum_add_u64(&meta, errno);
 604                         } else if (fd == -1) {
 605                                 fprintf(stderr, "open failed for %s/%s: %s\n",
 606                                         path_prefix, path, strerror(errno));
 607                                 exit(-1);
 608                         } else {
 609                                 ret = sum_xattrs(fd, &meta);
 610                                 close(fd);
 611                                 if (ret < 0) {
 612                                         fprintf(stderr,
 613                                                 "failed to read xattrs from "
 614                                                 "%s/%s: %s\n",
 615                                                 path_prefix, path,
 616                                                 strerror(-ret));
 617                                         exit(-1);
 618                                 }
 619                         }
 620                 }
 621                 if (S_ISDIR(st.st_mode)) {
 622                         fd = openat(dirfd, namelist[i], 0);
 623                         if (fd == -1 && flags[FLAG_OPEN_ERROR]) {
 624                                 sum_add_u64(&meta, errno);
 625                         } else if (fd == -1) {
 626                                 fprintf(stderr, "open failed for %s/%s: %s\n",
 627                                         path_prefix, path, strerror(errno));
 628                                 exit(-1);
 629                         } else {
 630                                 sum(fd, level + 1, &cs, path_prefix, path);
 631                                 close(fd);
 632                         }
 633                 } else if (S_ISREG(st.st_mode)) {
 634                         sum_add_u64(&meta, st.st_size);
 635                         if (flags[FLAG_DATA]) {
 636                                 if (verbose)
 637                                         fprintf(stderr, "file %s\n",
 638                                                 namelist[i]);
 639                                 fd = openat(dirfd, namelist[i], 0);
 640                                 if (fd == -1 && flags[FLAG_OPEN_ERROR]) {
 641                                         sum_add_u64(&meta, errno);
 642                                 } else if (fd == -1) {
 643                                         fprintf(stderr,
 644                                                 "open failed for %s/%s: %s\n",
 645                                                 path_prefix, path,
 646                                                 strerror(errno));
 647                                         exit(-1);
 648                                 }
 649                                 if (fd != -1) {
 650                                         ret = sum_file_data(fd, &cs);
 651                                         if (ret < 0) {
 652                                                 fprintf(stderr,
 653                                                         "read failed for "
 654                                                         "%s/%s: %s\n",
 655                                                         path_prefix, path,
 656                                                         strerror(errno));
 657                                                 exit(-1);
 658                                         }
 659                                         close(fd);
 660                                 }
 661                         }
 662                 } else if (S_ISLNK(st.st_mode)) {
 663                         ret = readlink(namelist[i], buf, sizeof(buf));
 664                         if (ret == -1) {
 665                                 perror("readlink");
 666                                 exit(-1);
 667                         }
 668                         sum_add(&cs, buf, ret);
 669                 } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
 670                         sum_add_u64(&cs, major(st.st_rdev));
 671                         sum_add_u64(&cs, minor(st.st_rdev));
 672                 }
 673                 sum_fini(&cs);
 674                 sum_fini(&meta);
 675                 if (gen_manifest || in_manifest) {
 676                         char *fn;
 677                         char *m;
 678                         char *c;
 679
 680                         if (S_ISDIR(st.st_mode))
 681                                 strcat(path, "/");
 682                         fn = escape(path);
 683                         m = sum_to_string(&meta);
 684                         c = sum_to_string(&cs);
 685
 686                         if (gen_manifest)
 687                                 fprintf(out_fp, "%s %s %s\n", fn, m, c);
 688                         if (in_manifest)
 689                                 check_manifest(fn, m, c, 0);
 690                         free(c);
 691                         free(m);
 692                         free(fn);
 693                 }
 694                 sum_add_sum(dircs, &cs);
 695                 sum_add_sum(dircs, &meta);
 696 next:
 697                 free(path);
 698         }
 699 }
 700
 701 int
 702 main(int argc, char *argv[])
 703 {
 704         extern char *optarg;
 705         extern int optind;
 706         int     c;
 707         char *path;
 708         int fd;
 709         sum_t cs;
 710         char flagstring[sizeof(flchar)];
 711         int i;
 712         int plen;
 713         int elen;
 714         int n_flags = 0;
 715         const char *allopts = "heEfuUgGoOaAmMcCdDtTsSnNw:r:vx:";
 716
 717         out_fp = stdout;
 718         while ((c = getopt(argc, argv, allopts)) != EOF) {
 719                 switch(c) {
 720                 case 'f':
 721                         gen_manifest = 1;
 722                         break;
 723                 case 'u':
 724                 case 'U':
 725                 case 'g':
 726                 case 'G':
 727                 case 'o':
 728                 case 'O':
 729                 case 'a':
 730                 case 'A':
 731                 case 'm':
 732                 case 'M':
 733                 case 'c':
 734                 case 'C':
 735                 case 'd':
 736                 case 'D':
 737                 case 'T':
 738                 case 't':
 739                 case 'e':
 740                 case 'E':
 741                 case 's':
 742                 case 'S':
 743                         ++n_flags;
 744                         parse_flag(c);
 745                         break;
 746                 case 'n':
 747                         for (i = 0; i < NUM_FLAGS; ++i)
 748                                 flags[i] = 0;
 749                         break;
 750                 case 'N':
 751                         for (i = 0; i < NUM_FLAGS; ++i)
 752                                 flags[i] = 1;
 753                         break;
 754                 case 'w':
 755                         out_fp = fopen(optarg, "w");
 756                         if (!out_fp) {
 757                                 fprintf(stderr,
 758                                         "failed to open output file: %s\n",
 759                                         strerror(errno));
 760                                 exit(-1);
 761                         }
 762                         break;
 763                 case 'r':
 764                         in_fp = fopen(optarg, "r");
 765                         if (!in_fp) {
 766                                 fprintf(stderr,
 767                                         "failed to open input file: %s\n",
 768                                         strerror(errno));
 769                                 exit(-1);
 770                         }
 771                         break;
 772                 case 'x':
 773                         ++n_excludes;
 774                         excludes = realloc(excludes,
 775                                            sizeof(*excludes) * n_excludes);
 776                         if (!excludes) {
 777                                 fprintf(stderr,
 778                                         "failed to alloc exclude space\n");
 779                                 exit(-1);
 780                         }
 781                         excludes[n_excludes - 1].path = optarg;
 782                         break;
 783                 case 'v':
 784                         ++verbose;
 785                         break;
 786                 case 'h':
 787                 case '?':
 788                         usage();
 789                 }
 790         }
 791
 792         if (optind + 1 != argc) {
 793                 fprintf(stderr, "missing path\n");
 794                 usage();
 795         }
 796
 797         if (in_fp) {
 798                 char *l = getln(line, sizeof(line), in_fp);
 799                 char *p;
 800
 801                 if (l == NULL) {
 802                         fprintf(stderr, "failed to read line from input\n");
 803                         exit(-1);
 804                 }
 805                 if (strncmp(l, "Flags: ", 7) == 0) {
 806                         l += 7;
 807                         in_manifest = 1;
 808                         parse_flags(l);
 809                 } else if ((p = strchr(l, ':'))) {
 810                         *p++ = 0;
 811                         parse_flags(l);
 812                         checksum = strdup(p);
 813                 } else {
 814                         fprintf(stderr, "invalid input file format\n");
 815                         exit(-1);
 816                 }
 817                 if (n_flags)
 818                         fprintf(stderr, "warning: "
 819                                 "command line flags ignored in -r mode\n");
 820         }
 821         strcpy(flagstring, flchar);
 822         for (i = 0; i < NUM_FLAGS; ++i) {
 823                 if (flags[i] == 0)
 824                         flagstring[i] -= 'a' - 'A';
 825         }
 826
 827         path = argv[optind];
 828         plen = strlen(path);
 829         if (path[plen - 1] == '/') {
 830                 --plen;
 831                 path[plen] = '\0';
 832         }
 833
 834         for (i = 0; i < n_excludes; ++i) {
 835                 if (strncmp(path, excludes[i].path, plen) != 0)
 836                         fprintf(stderr,
 837                                 "warning: exclude %s outside of path %s\n",
 838                                 excludes[i].path, path);
 839                 else
 840                         excludes[i].path += plen;
 841                 elen = strlen(excludes[i].path);
 842                 if (excludes[i].path[elen - 1] == '/')
 843                         --elen;
 844                 excludes[i].path[elen] = '\0';
 845                 excludes[i].len = elen;
 846         }
 847
 848         fd = open(path, O_RDONLY);
 849         if (fd == -1) {
 850                 fprintf(stderr, "failed to open %s: %s\n", path,
 851                         strerror(errno));
 852                 exit(-1);
 853         }
 854
 855         if (gen_manifest)
 856                 fprintf(out_fp, "Flags: %s\n", flagstring);
 857
 858         sum_init(&cs);
 859         sum(fd, 1, &cs, path, "");
 860         sum_fini(&cs);
 861
 862         close(fd);
 863         if (in_manifest)
 864                 check_manifest("", "", "", 1);
 865
 866         if (!checksum) {
 867                 if (in_manifest) {
 868                         fprintf(stderr, "malformed input\n");
 869                         exit(-1);
 870                 }
 871                 if (!gen_manifest)
 872                         fprintf(out_fp, "%s:", flagstring);
 873
 874                 fprintf(out_fp, "%s\n", sum_to_string(&cs));
 875         } else {
 876                 if (strcmp(checksum, sum_to_string(&cs)) == 0) {
 877                         printf("OK\n");
 878                         exit(0);
 879                 } else {
 880                         printf("FAIL\n");
 881                         exit(1);
 882                 }
 883         }
 884
 885         exit(0);
 886 }