src/metastore.c

   1 /*
   2  * Main functions of the program.
   3  *
   4  * Copyright (C) 2007 David Härdeman <david@hardeman.nu>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #define _BSD_SOURCE
  21 #define _DEFAULT_SOURCE
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <getopt.h>
  25 #include <utime.h>
  26 #include <sys/xattr.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32 #include "metastore.h"
  33 #include "settings.h"
  34 #include "utils.h"
  35 #include "metaentry.h"
  36
  37 /* metastore settings */
  38 static struct metasettings settings = {
  39         .metafile = METAFILE,
  40         .do_mtime = false,
  41         .do_emptydirs = false,
  42         .do_removeemptydirs = false,
  43         .do_git = false,
  44 };
  45
  46 /* Used to create lists of dirs / other files which are missing in the fs */
  47 static struct metaentry *missingdirs = NULL;
  48 static struct metaentry *missingothers = NULL;
  49
  50 /* Used to create lists of dirs / other files which are missing in metadata */
  51 static struct metaentry *extradirs = NULL;
  52
  53 /*
  54  * Inserts an entry in a linked list ordered by pathlen
  55  */
  56 static void
  57 insert_entry_plist(struct metaentry **list, struct metaentry *entry)
  58 {
  59         struct metaentry **parent;
  60
  61         for (parent = list; *parent; parent = &((*parent)->list)) {
  62                 if ((*parent)->pathlen > entry->pathlen)
  63                         break;
  64         }
  65
  66         entry->list = *parent;
  67         *parent = entry;
  68 }
  69
  70 /*
  71  * Inserts an entry in a linked list ordered by pathlen descendingly
  72  */
  73 static void
  74 insert_entry_pdlist(struct metaentry **list, struct metaentry *entry)
  75 {
  76         struct metaentry **parent;
  77
  78         for (parent = list; *parent; parent = &((*parent)->list)) {
  79                 if ((*parent)->pathlen < entry->pathlen)
  80                         break;
  81         }
  82
  83         entry->list = *parent;
  84         *parent = entry;
  85 }
  86
  87 /*
  88  * Prints differences between real and stored actual metadata
  89  * - for use in mentries_compare
  90  */
  91 static void
  92 compare_print(struct metaentry *real, struct metaentry *stored, int cmp)
  93 {
  94         if (!real && !stored) {
  95                 msg(MSG_ERROR, "%s called with incorrect arguments\n", __func__);
  96                 return;
  97         }
  98
  99         if (cmp == DIFF_NONE) {
 100                 msg(MSG_DEBUG, "%s:\tno difference\n", real->path);
 101                 return;
 102         }
 103
 104         msg(MSG_QUIET, "%s:\t", real ? real->path : stored->path);
 105
 106         if (cmp & DIFF_ADDED)
 107                 msg(MSG_QUIET, "added ", real->path);
 108         if (cmp & DIFF_DELE)
 109                 msg(MSG_QUIET, "removed ", stored->path);
 110         if (cmp & DIFF_OWNER)
 111                 msg(MSG_QUIET, "owner ");
 112         if (cmp & DIFF_GROUP)
 113                 msg(MSG_QUIET, "group ");
 114         if (cmp & DIFF_MODE)
 115                 msg(MSG_QUIET, "mode ");
 116         if (cmp & DIFF_TYPE)
 117                 msg(MSG_QUIET, "type ");
 118         if (cmp & DIFF_MTIME)
 119                 msg(MSG_QUIET, "mtime ");
 120         if (cmp & DIFF_XATTR)
 121                 msg(MSG_QUIET, "xattr ");
 122         msg(MSG_QUIET, "\n");
 123 }
 124
 125 /*
 126  * Tries to change the real metadata to match the stored one
 127  * - for use in mentries_compare
 128  */
 129 static void
 130 compare_fix(struct metaentry *real, struct metaentry *stored, int cmp)
 131 {
 132         struct group *group;
 133         struct passwd *owner;
 134         gid_t gid = -1;
 135         uid_t uid = -1;
 136         struct utimbuf tbuf;
 137         unsigned i;
 138
 139         if (!real && !stored) {
 140                 msg(MSG_ERROR, "%s called with incorrect arguments\n", __func__);
 141                 return;
 142         }
 143
 144         if (!real) {
 145                 if (S_ISDIR(stored->mode))
 146                         insert_entry_plist(&missingdirs, stored);
 147                 else
 148                         insert_entry_plist(&missingothers, stored);
 149
 150                 msg(MSG_NORMAL, "%s:\tremoved\n", stored->path);
 151                 return;
 152         }
 153
 154         if (!stored) {
 155                 if (S_ISDIR(real->mode))
 156                         insert_entry_pdlist(&extradirs, real);
 157                 msg(MSG_NORMAL, "%s:\tadded\n", real->path);
 158                 return;
 159         }
 160
 161         if (cmp == DIFF_NONE) {
 162                 msg(MSG_DEBUG, "%s:\tno difference\n", real->path);
 163                 return;
 164         }
 165
 166         if (cmp & DIFF_TYPE) {
 167                 msg(MSG_NORMAL, "%s:\tnew type, will not change metadata\n",
 168                     real->path);
 169                 return;
 170         }
 171
 172         msg(MSG_QUIET, "%s:\tchanging metadata\n", real->path);
 173
 174         while (cmp & (DIFF_OWNER | DIFF_GROUP)) {
 175                 if (cmp & DIFF_OWNER) {
 176                         msg(MSG_NORMAL, "%s:\tchanging owner from %s to %s\n",
 177                             real->path, real->group, stored->group);
 178                         owner = xgetpwnam(stored->owner);
 179                         if (!owner) {
 180                                 msg(MSG_DEBUG, "\tgetpwnam failed: %s\n",
 181                                     strerror(errno));
 182                                 break;
 183                         }
 184                         uid = owner->pw_uid;
 185                 }
 186
 187                 if (cmp & DIFF_GROUP) {
 188                         msg(MSG_NORMAL, "%s:\tchanging group from %s to %s\n",
 189                             real->path, real->group, stored->group);
 190                         group = xgetgrnam(stored->group);
 191                         if (!group) {
 192                                 msg(MSG_DEBUG, "\tgetgrnam failed: %s\n",
 193                                     strerror(errno));
 194                                 break;
 195                         }
 196                         gid = group->gr_gid;
 197                 }
 198
 199                 if (lchown(real->path, uid, gid)) {
 200                         msg(MSG_DEBUG, "\tlchown failed: %s\n",
 201                             strerror(errno));
 202                         break;
 203                 }
 204                 break;
 205         }
 206
 207         if (cmp & DIFF_MODE) {
 208                 msg(MSG_NORMAL, "%s:\tchanging mode from 0%o to 0%o\n",
 209                     real->path, real->mode & 07777, stored->mode & 07777);
 210                 if (chmod(real->path, stored->mode & 07777))
 211                         msg(MSG_DEBUG, "\tchmod failed: %s\n", strerror(errno));
 212         }
 213
 214         /* FIXME: Use utimensat here, or even better - lutimensat */
 215         if ((cmp & DIFF_MTIME) && S_ISLNK(real->mode)) {
 216                 msg(MSG_NORMAL, "%s:\tsymlink, not changing mtime\n", real->path);
 217         } else if (cmp & DIFF_MTIME) {
 218                 msg(MSG_NORMAL, "%s:\tchanging mtime from %ld to %ld\n",
 219                     real->path, real->mtime, stored->mtime);
 220                 tbuf.actime = stored->mtime;
 221                 tbuf.modtime = stored->mtime;
 222                 if (utime(real->path, &tbuf)) {
 223                         msg(MSG_DEBUG, "\tutime failed: %s\n", strerror(errno));
 224                         return;
 225                 }
 226         }
 227
 228         if (cmp & DIFF_XATTR) {
 229                 for (i = 0; i < real->xattrs; i++) {
 230                         /* Any attrs to remove? */
 231                         if (mentry_find_xattr(stored, real, i) >= 0)
 232                                 continue;
 233
 234                         msg(MSG_NORMAL, "%s:\tremoving xattr %s\n",
 235                             real->path, real->xattr_names[i]);
 236                         if (lremovexattr(real->path, real->xattr_names[i]))
 237                                 msg(MSG_DEBUG, "\tlremovexattr failed: %s\n",
 238                                     strerror(errno));
 239                 }
 240
 241                 for (i = 0; i < stored->xattrs; i++) {
 242                         /* Any xattrs to add? (on change they are removed above) */
 243                         if (mentry_find_xattr(real, stored, i) >= 0)
 244                                 continue;
 245
 246                         msg(MSG_NORMAL, "%s:\tadding xattr %s\n",
 247                             stored->path, stored->xattr_names[i]);
 248                         if (lsetxattr(stored->path, stored->xattr_names[i],
 249                                       stored->xattr_values[i],
 250                                       stored->xattr_lvalues[i], XATTR_CREATE)
 251                            )
 252                                 msg(MSG_DEBUG, "\tlsetxattr failed: %s\n",
 253                                     strerror(errno));
 254                 }
 255         }
 256 }
 257
 258 /*
 259  * Tries to fix any empty dirs which are missing from the filesystem by
 260  * recreating them.
 261  */
 262 static void
 263 fixup_emptydirs(void)
 264 {
 265         struct metaentry *entry;
 266         struct metaentry *cur;
 267         struct metaentry **parent;
 268         char *bpath;
 269         char *delim;
 270         size_t blen;
 271         struct metaentry *new;
 272
 273         if (!missingdirs)
 274                 return;
 275         msg(MSG_DEBUG, "\nAttempting to recreate missing dirs\n");
 276
 277         /* If directory x/y is missing, but file x/y/z is also missing,
 278          * we should prune directory x/y from the list of directories to
 279          * recreate since the deletition of x/y is likely to be genuine
 280          * (as opposed to empty dir pruning like git/cvs does).
 281          *
 282          * Also, if file x/y/z is missing, any child directories of
 283          * x/y should be pruned as they are probably also intentionally
 284          * removed.
 285          */
 286
 287         msg(MSG_DEBUG, "List of candidate dirs:\n");
 288         for (cur = missingdirs; cur; cur = cur->list)
 289                 msg(MSG_DEBUG, " %s\n", cur->path);
 290
 291         for (entry = missingothers; entry; entry = entry->list) {
 292                 msg(MSG_DEBUG, "Pruning using file %s\n", entry->path);
 293                 bpath = xstrdup(entry->path);
 294                 delim = strrchr(bpath, '/');
 295                 if (!delim) {
 296                         msg(MSG_NORMAL, "No delimiter found in %s\n", bpath);
 297                         free(bpath);
 298                         continue;
 299                 }
 300                 *delim = '\0';
 301
 302                 parent = &missingdirs;
 303                 for (cur = *parent; cur; cur = cur->list) {
 304                         if (strcmp(cur->path, bpath)) {
 305                                 parent = &cur->list;
 306                                 continue;
 307                         }
 308
 309                         msg(MSG_DEBUG, "Prune phase 1 - %s\n", cur->path);
 310                         *parent = cur->list;
 311                 }
 312
 313                 /* Now also prune subdirs of the base dir */
 314                 *delim++ = '/';
 315                 *delim = '\0';
 316                 blen = strlen(bpath);
 317
 318                 parent = &missingdirs;
 319                 for (cur = *parent; cur; cur = cur->list) {
 320                         if (strncmp(cur->path, bpath, blen)) {
 321                                 parent = &cur->list;
 322                                 continue;
 323                         }
 324
 325                         msg(MSG_DEBUG, "Prune phase 2 - %s\n", cur->path);
 326                         *parent = cur->list;
 327                 }
 328
 329                 free(bpath);
 330         }
 331         msg(MSG_DEBUG, "\n");
 332
 333         for (cur = missingdirs; cur; cur = cur->list) {
 334                 msg(MSG_QUIET, "%s:\trecreating...", cur->path);
 335                 if (mkdir(cur->path, cur->mode)) {
 336                         msg(MSG_QUIET, "failed (%s)\n", strerror(errno));
 337                         continue;
 338                 }
 339                 msg(MSG_QUIET, "ok\n");
 340
 341                 new = mentry_create(cur->path);
 342                 if (!new) {
 343                         msg(MSG_QUIET, "Failed to get metadata for %s\n");
 344                         continue;
 345                 }
 346
 347                 compare_fix(new, cur, mentry_compare(new, cur, &settings));
 348         }
 349 }
 350
 351 /*
 352  * Deletes any empty dirs present in the filesystem that are missing
 353  * from the metadata.
 354  * An "empty" dir is one which either:
 355  *  - is empty; or
 356  *  - only contains empty dirs
 357  */
 358 static void
 359 fixup_newemptydirs(void)
 360 {
 361         struct metaentry **cur;
 362         int removed_dirs = 1;
 363
 364         if (!extradirs)
 365                 return;
 366
 367         /* This is a simpleminded algorithm that attempts to rmdir() all
 368          * directories discovered missing from the metadata. Naturally, this will
 369          * succeed only on the truly empty directories, but depending on the order,
 370          * it may mean that parent directory removal are attempted to be removed
 371          * *before* the children. To circumvent this, keep looping around all the
 372          * directories until none have been successfully removed.  This is a
 373          * O(N**2) algorithm, so don't try to remove too many nested directories
 374          * at once (e.g. thousands).
 375          *
 376          * Note that this will succeed only if each parent directory is writable.
 377          */
 378         while (removed_dirs) {
 379                 removed_dirs = 0;
 380                 msg(MSG_DEBUG, "\nAttempting to delete empty dirs\n");
 381                 for (cur = &extradirs; *cur;) {
 382                         msg(MSG_QUIET, "%s:\tremoving...", (*cur)->path);
 383                         if (rmdir((*cur)->path)) {
 384                                 msg(MSG_QUIET, "failed (%s)\n", strerror(errno));
 385                                 cur = &(*cur)->list;
 386                                 continue;
 387                         }
 388                         /* No freeing, because OS will do the job at the end. */
 389                         *cur = (*cur)->list;
 390                         removed_dirs++;
 391                         msg(MSG_QUIET, "ok\n");
 392                 }
 393         }
 394 }
 395
 396 /* Outputs version information and exits */
 397 static void
 398 version(void)
 399 {
 400         msg(MSG_QUIET, "metastore %s\n", METASTORE_VER);
 401
 402         exit(EXIT_SUCCESS);
 403 }
 404
 405 /* Prints usage message and exits */
 406 static void
 407 usage(const char *arg0, const char *message)
 408 {
 409         if (message)
 410                 msg(MSG_CRITICAL, "%s: %s\n\n", arg0, message);
 411         msg(MSG_CRITICAL,
 412 "Usage: %s ACTION [OPTION...] [PATH...]\n",
 413             arg0);
 414         msg(MSG_CRITICAL,
 415 "\n"
 416 "Where ACTION is one of:\n"
 417 "  -c, --compare            Show differences between stored and real metadata\n"
 418 "  -s, --save               Save current metadata\n"
 419 "  -a, --apply              Apply stored metadata\n"
 420 "  -d, --dump               Dump stored (if no PATH is given) or real metadata\n"
 421 "                           (if PATH is present, e.g. ./) in human-readable form\n"
 422 "  -V, --version            Output version information and exit\n"
 423 "  -h, --help               Help message (this text)\n"
 424 "\n"
 425 "Valid OPTIONS are:\n"
 426 "  -v, --verbose            Print more verbose messages\n"
 427 "  -q, --quiet              Print less verbose messages\n"
 428 "  -m, --mtime              Also take mtime into account for diff or apply\n"
 429 "  -e, --empty-dirs         Recreate missing empty directories\n"
 430 "  -E, --remove-empty-dirs  Remove extra empty directories\n"
 431 "  -g, --git                Do not omit .git directories\n"
 432 "  -f, --file=FILE          Set metadata file (" METAFILE " by default)\n"
 433             );
 434
 435         exit(message ? EXIT_FAILURE : EXIT_SUCCESS);
 436 }
 437
 438 /* Options */
 439 static struct option long_options[] = {
 440         { "compare",           no_argument,       NULL, 'c' },
 441         { "save",              no_argument,       NULL, 's' },
 442         { "apply",             no_argument,       NULL, 'a' },
 443         { "dump",              no_argument,       NULL, 'd' },
 444         { "version",           no_argument,       NULL, 'V' },
 445         { "help",              no_argument,       NULL, 'h' },
 446         { "verbose",           no_argument,       NULL, 'v' },
 447         { "quiet",             no_argument,       NULL, 'q' },
 448         { "mtime",             no_argument,       NULL, 'm' },
 449         { "empty-dirs",        no_argument,       NULL, 'e' },
 450         { "remove-empty-dirs", no_argument,       NULL, 'E' },
 451         { "git",               no_argument,       NULL, 'g' },
 452         { "file",              required_argument, NULL, 'f' },
 453         { NULL, 0, NULL, 0 }
 454 };
 455
 456 /* Main function */
 457 int
 458 main(int argc, char **argv)
 459 {
 460         int i, c;
 461         struct metahash *real = NULL;
 462         struct metahash *stored = NULL;
 463         int action = 0;
 464
 465         /* Parse options */
 466         i = 0;
 467         while (1) {
 468                 int option_index = 0;
 469                 c = getopt_long(argc, argv, "csadVhvqmeEgf:",
 470                                 long_options, &option_index);
 471                 if (c == -1)
 472                         break;
 473                 switch (c) {
 474                 case 'c': /* compare */           action |= ACTION_DIFF;  i++;   break;
 475                 case 's': /* save */              action |= ACTION_SAVE;  i++;   break;
 476                 case 'a': /* apply */             action |= ACTION_APPLY; i++;   break;
 477                 case 'd': /* dump */              action |= ACTION_DUMP;  i++;   break;
 478                 case 'V': /* version */           action |= ACTION_VER;   i++;   break;
 479                 case 'h': /* help */              action |= ACTION_HELP;  i++;   break;
 480                 case 'v': /* verbose */           adjust_verbosity(1);           break;
 481                 case 'q': /* quiet */             adjust_verbosity(-1);          break;
 482                 case 'm': /* mtime */             settings.do_mtime = true;      break;
 483                 case 'e': /* empty-dirs */        settings.do_emptydirs = true;  break;
 484                 case 'E': /* remove-empty-dirs */ settings.do_removeemptydirs = true;
 485                                                       break;
 486                 case 'g': /* git */               settings.do_git = true;        break;
 487                 case 'f': /* file */              settings.metafile = optarg;    break;
 488                 default:
 489                         usage(argv[0], "unknown option");
 490                 }
 491         }
 492
 493         /* Make sure only one action is specified */
 494         if (i != 1)
 495                 usage(argv[0], "incorrect option(s)");
 496
 497         /* Make sure --empty-dirs is only used with apply */
 498         if (settings.do_emptydirs && action != ACTION_APPLY)
 499                 usage(argv[0], "--empty-dirs is only valid with --apply");
 500
 501         /* Make sure --remove-empty-dirs is only used with apply */
 502         if (settings.do_removeemptydirs && action != ACTION_APPLY)
 503                 usage(argv[0], "--remove-empty-dirs is only valid with --apply");
 504
 505         if (action == ACTION_VER)
 506                 version();
 507
 508         if (action == ACTION_HELP)
 509                 usage(argv[0], NULL);
 510
 511         /* Perform action */
 512         if (action & ACTIONS_READING && !(action == ACTION_DUMP && optind < argc)) {
 513                 mentries_fromfile(&stored, settings.metafile);
 514                 if (!stored) {
 515                         msg(MSG_CRITICAL, "Failed to load metadata from %s\n",
 516                             settings.metafile);
 517                         exit(EXIT_FAILURE);
 518                 }
 519         }
 520
 521         if (optind < argc) {
 522                 while (optind < argc)
 523                         mentries_recurse_path(argv[optind++], &real, &settings);
 524         } else if (action != ACTION_DUMP) {
 525                 mentries_recurse_path(".", &real, &settings);
 526         }
 527
 528         if (!real && (action != ACTION_DUMP || optind < argc)) {
 529                 msg(MSG_CRITICAL,
 530                     "Failed to load metadata from file system\n");
 531                 exit(EXIT_FAILURE);
 532         }
 533
 534         switch (action) {
 535         case ACTION_DIFF:
 536                 mentries_compare(real, stored, compare_print, &settings);
 537                 break;
 538         case ACTION_SAVE:
 539                 mentries_tofile(real, settings.metafile);
 540                 break;
 541         case ACTION_APPLY:
 542                 mentries_compare(real, stored, compare_fix, &settings);
 543                 if (settings.do_emptydirs)
 544                         fixup_emptydirs();
 545                 if (settings.do_removeemptydirs)
 546                         fixup_newemptydirs();
 547                 break;
 548         case ACTION_DUMP:
 549                 mentries_dump(real ? real : stored);
 550                 break;
 551         }
 552
 553         exit(EXIT_SUCCESS);
 554 }