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 version 2 of the License.
   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
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <pwd.h>
  24 #include <grp.h>
  25 #include <getopt.h>
  26 #include <utime.h>
  27 #include <attr/xattr.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include "metastore.h"
  33 #include "utils.h"
  34 #include "metaentry.h"
  35
  36 /* Used to signal whether mtimes should be corrected */
  37 static int do_mtime = 0;
  38
  39 /*
  40  * Prints differences between real and stored actual metadata
  41  * - for use in mentries_compare
  42  */
  43 static void
  44 compare_print(struct metaentry *real, struct metaentry *stored, int cmp)
  45 {
  46         if (!real) {
  47                 msg(MSG_QUIET, "%s:\tremoved\n", stored->path);
  48                 return;
  49         }
  50
  51         if (!stored) {
  52                 msg(MSG_QUIET, "%s:\tadded\n", real->path);
  53                 return;
  54         }
  55
  56         if (cmp == DIFF_NONE) {
  57                 msg(MSG_DEBUG, "%s:\tno difference\n", real->path);
  58                 return;
  59         }
  60
  61         msg(MSG_QUIET, "%s:\t", real->path);
  62         if (cmp & DIFF_OWNER)
  63                 msg(MSG_QUIET, "owner ");
  64         if (cmp & DIFF_GROUP)
  65                 msg(MSG_QUIET, "group ");
  66         if (cmp & DIFF_MODE)
  67                 msg(MSG_QUIET, "mode ");
  68         if (cmp & DIFF_TYPE)
  69                 msg(MSG_QUIET, "type ");
  70         if (cmp & DIFF_MTIME)
  71                 msg(MSG_QUIET, "mtime ");
  72         if (cmp & DIFF_XATTR)
  73                 msg(MSG_QUIET, "xattr ");
  74         msg(MSG_QUIET, "\n");
  75 }
  76
  77 /*
  78  * Tries to change the real metadata to match the stored one
  79  * - for use in mentries_compare
  80  */
  81 static void
  82 compare_fix(struct metaentry *real, struct metaentry *stored, int cmp)
  83 {
  84         struct group *group;
  85         struct passwd *owner;
  86         gid_t gid = -1;
  87         uid_t uid = -1;
  88         struct utimbuf tbuf;
  89         int i;
  90
  91         if (!real && !stored) {
  92                 msg(MSG_ERROR, "%s called with incorrect arguments\n",
  93                     __FUNCTION__);
  94                 return;
  95         }
  96
  97         if (!real) {
  98                 msg(MSG_NORMAL, "%s:\tremoved\n", stored->path);
  99                 return;
 100         }
 101
 102         if (!stored) {
 103                 msg(MSG_NORMAL, "%s:\tadded\n", real->path);
 104                 return;
 105         }
 106
 107         if (cmp == DIFF_NONE) {
 108                 msg(MSG_DEBUG, "%s:\tno difference\n", real->path);
 109                 return;
 110         }
 111
 112         if (cmp & DIFF_TYPE) {
 113                 msg(MSG_NORMAL, "%s:\tnew type, will not change metadata\n",
 114                     real->path);
 115                 return;
 116         }
 117
 118         msg(MSG_QUIET, "%s:\tchanging metadata\n", real->path);
 119
 120         while (cmp & (DIFF_OWNER | DIFF_GROUP)) {
 121                 if (cmp & DIFF_OWNER) {
 122                         msg(MSG_NORMAL, "\tchanging owner from %s to %s\n",
 123                             real->path, real->group, stored->group);
 124                         owner = getpwnam(stored->owner);
 125                         if (!owner) {
 126                                 msg(MSG_DEBUG, "\tgetpwnam failed: %s\n",
 127                                     strerror(errno));
 128                                 break;
 129                         }
 130                         uid = owner->pw_uid;
 131                 }
 132
 133                 if (cmp & DIFF_GROUP) {
 134                         msg(MSG_NORMAL, "\tchanging group from %s to %s\n",
 135                             real->path, real->group, stored->group);
 136                         group = getgrnam(stored->group);
 137                         if (!group) {
 138                                 msg(MSG_DEBUG, "\tgetgrnam failed: %s\n",
 139                                     strerror(errno));
 140                                 break;
 141                         }
 142                         gid = group->gr_gid;
 143                 }
 144
 145                 if (lchown(real->path, uid, gid)) {
 146                         msg(MSG_DEBUG, "\tlchown failed: %s\n",
 147                             strerror(errno));
 148                         break;
 149                 }
 150                 break;
 151         }
 152
 153         if (cmp & DIFF_MODE) {
 154                 msg(MSG_NORMAL, "%s:\tchanging mode from 0%o to 0%o\n",
 155                     real->path, real->mode, stored->mode);
 156                 if (chmod(real->path, real->mode))
 157                         msg(MSG_DEBUG, "\tchmod failed: %s\n", strerror(errno));
 158         }
 159
 160         if (cmp & DIFF_MTIME) {
 161                 msg(MSG_NORMAL, "%s:\tchanging mtime from %ld to %ld\n",
 162                     real->path, real->mtime, stored->mtime);
 163                 /* FIXME: Use utimensat here */
 164                 tbuf.actime = stored->mtime;
 165                 tbuf.modtime = stored->mtime;
 166                 if (utime(real->path, &tbuf)) {
 167                         msg(MSG_DEBUG, "\tutime failed: %s\n", strerror(errno));
 168                         return;
 169                 }
 170         }
 171
 172         if (cmp & DIFF_XATTR) {
 173                 for (i = 0; i < real->xattrs; i++) {
 174                         /* Any attrs to remove? */
 175                         if (mentry_find_xattr(stored, real, i) >= 0)
 176                                 continue;
 177
 178                         msg(MSG_NORMAL, "%s:\tremoving xattr %s\n",
 179                             real->path, real->xattr_names[i]);
 180                         if (lremovexattr(real->path, real->xattr_names[i]))
 181                                 msg(MSG_DEBUG, "\tlremovexattr failed: %s\n",
 182                                     strerror(errno));
 183                 }
 184
 185                 for (i = 0; i < stored->xattrs; i++) {
 186                         /* Any xattrs to add? (on change they are removed above) */
 187                         if (mentry_find_xattr(real, stored, i) >= 0)
 188                                 continue;
 189
 190                         msg(MSG_NORMAL, "%s:\tadding xattr %s\n",
 191                             stored->path, stored->xattr_names[i]);
 192                         if (lsetxattr(stored->path, stored->xattr_names[i],
 193                                       stored->xattr_values[i],
 194                                       stored->xattr_lvalues[i], XATTR_CREATE))
 195                                 msg(MSG_DEBUG, "\tlsetxattr failed: %s\n",
 196                                     strerror(errno));
 197                 }
 198         }
 199 }
 200
 201 /* Prints usage message and exits */
 202 static void
 203 usage(const char *arg0, const char *message)
 204 {
 205         if (message)
 206                 msg(MSG_CRITICAL, "%s: %s\n\n", arg0, msg);
 207         msg(MSG_CRITICAL, "Usage: %s ACTION [OPTION...] [PATH...]\n\n", arg0);
 208         msg(MSG_CRITICAL, "Where ACTION is one of:\n"
 209             "  -c, --compare\tShow differences between stored and real metadata\n"
 210             "  -s, --save\tSave current metadata\n"
 211             "  -a, --apply\tApply stored metadata\n"
 212             "  -h, --help\tHelp message (this text)\n\n"
 213             "Valid OPTIONS are (can be given more than once):\n"
 214             "  -v, --verbose\tPrint more verbose messages\n"
 215             "  -q, --quiet\tPrint less verbose messages\n"
 216             "  -m, --mtime\tAlso take mtime into account for diff or apply\n");
 217
 218         exit(message ? EXIT_FAILURE : EXIT_SUCCESS);
 219 }
 220
 221 /* Options */
 222 static struct option long_options[] = {
 223         {"compare", 0, 0, 0},
 224         {"save", 0, 0, 0},
 225         {"apply", 0, 0, 0},
 226         {"help", 0, 0, 0},
 227         {"verbose", 0, 0, 0},
 228         {"quiet", 0, 0, 0},
 229         {"mtime", 0, 0, 0},
 230         {0, 0, 0, 0}
 231 };
 232
 233 /* Main function */
 234 int
 235 main(int argc, char **argv, char **envp)
 236 {
 237         int i, c;
 238         struct metaentry *lreal = NULL;
 239         struct metaentry *lstored = NULL;
 240         int action = 0;
 241
 242         /* Parse options */
 243         i = 0;
 244         while (1) {
 245                 int option_index = 0;
 246                 c = getopt_long(argc, argv, "csahvqm",
 247                                 long_options, &option_index);
 248                 if (c == -1)
 249                         break;
 250                 switch (c) {
 251                 case 0:
 252                         if (!strcmp("verbose",
 253                                     long_options[option_index].name)) {
 254                                 adjust_verbosity(1);
 255                         } else if (!strcmp("quiet",
 256                                            long_options[option_index].name)) {
 257                                 adjust_verbosity(-1);
 258                         } else if (!strcmp("mtime",
 259                                            long_options[option_index].name)) {
 260                                 do_mtime = 1;
 261                         } else {
 262                                 action |= (1 << option_index);
 263                                 i++;
 264                         }
 265                         break;
 266                 case 'c':
 267                         action |= ACTION_DIFF;
 268                         i++;
 269                         break;
 270                 case 's':
 271                         action |= ACTION_SAVE;
 272                         i++;
 273                         break;
 274                 case 'a':
 275                         action |= ACTION_APPLY;
 276                         i++;
 277                         break;
 278                 case 'h':
 279                         action |= ACTION_HELP;
 280                         i++;
 281                         break;
 282                 case 'v':
 283                         adjust_verbosity(1);
 284                         break;
 285                 case 'q':
 286                         adjust_verbosity(-1);
 287                         break;
 288                 case 'm':
 289                         do_mtime = 1;
 290                         break;
 291                 default:
 292                         usage(argv[0], "unknown option");
 293                 }
 294         }
 295
 296         /* Make sure only one action is specified */
 297         if (i != 1)
 298                 usage(argv[0], "incorrect option(s)");
 299
 300         /* Perform action */
 301         switch (action) {
 302         case ACTION_DIFF:
 303                 mentries_fromfile(&lstored, METAFILE);
 304                 if (!lstored) {
 305                         msg(MSG_CRITICAL, "Failed to load metadata from %s\n",
 306                             METAFILE);
 307                         exit(EXIT_FAILURE);
 308                 }
 309
 310                 if (optind < argc) {
 311                         while (optind < argc)
 312                                 mentries_recurse_path(argv[optind++], &lreal);
 313                 } else {
 314                         mentries_recurse_path(".", &lreal);
 315                 }
 316
 317                 if (!lreal) {
 318                         msg(MSG_CRITICAL,
 319                             "Failed to load metadata from file system\n");
 320                         exit(EXIT_FAILURE);
 321                 }
 322
 323                 mentries_compare(lreal, lstored, compare_print, do_mtime);
 324                 break;
 325
 326         case ACTION_SAVE:
 327                 if (optind < argc) {
 328                         while (optind < argc)
 329                                 mentries_recurse_path(argv[optind++], &lreal);
 330                 } else {
 331                         mentries_recurse_path(".", &lreal);
 332                 }
 333
 334                 if (!lreal) {
 335                         msg(MSG_CRITICAL,
 336                             "Failed to load metadata from file system\n");
 337                         exit(EXIT_FAILURE);
 338                 }
 339
 340                 mentries_tofile(lreal, METAFILE);
 341                 break;
 342
 343         case ACTION_APPLY:
 344                 mentries_fromfile(&lstored, METAFILE);
 345                 if (!lstored) {
 346                         msg(MSG_CRITICAL, "Failed to load metadata from %s\n",
 347                             METAFILE);
 348                         exit(EXIT_FAILURE);
 349                 }
 350
 351                 if (optind < argc) {
 352                         while (optind < argc)
 353                                 mentries_recurse_path(argv[optind++], &lreal);
 354                 } else {
 355                         mentries_recurse_path(".", &lreal);
 356                 }
 357
 358                 if (!lreal) {
 359                         msg(MSG_CRITICAL,
 360                             "Failed to load metadata from file system\n");
 361                         exit(EXIT_FAILURE);
 362                 }
 363
 364                 mentries_compare(lreal, lstored, compare_fix, do_mtime);
 365                 break;
 366
 367         case ACTION_HELP:
 368                 usage(argv[0], NULL);
 369         }
 370
 371         exit(EXIT_SUCCESS);
 372 }
 373