usr/src/cmd/filesync/main.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * module:
  28  *      main.c
  29  *
  30  * purpose:
  31  *      argument handling and top level dispatch
  32  *
  33  * contents:
  34  *      main            argument handling and main loop
  35  *      usage           (static) print out usage message
  36  *      confirm         prompt the user for a confirmation and get it
  37  *      nomem           fatal error handler for malloc failures
  38  *      findfiles       (static) locate our baseline and rules files
  39  *      cleanup         (static) unlock baseline and delete temp file
  40  *      check_access    (static) do we have adequate access to a file/directory
  41  *      whoami          (static) get uid/gid/umask
  42  */
  43
  44 #pragma ident   "%Z%%M% %I%     %E% SMI"
  45
  46 #include <unistd.h>
  47 #include <stdlib.h>
  48 #include <fcntl.h>
  49 #include <stdio.h>
  50 #include <string.h>
  51 #include <ctype.h>
  52 #include <errno.h>
  53 #include <sys/stat.h>
  54
  55 #include "filesync.h"
  56 #include "database.h"
  57 #include "messages.h"
  58 #include "debug.h"
  59
  60 /*
  61  * local routines in this module:
  62  */
  63 static errmask_t findfiles();           /* find rule and baseline files */
  64 static void cleanup(int);               /* cleanup locks and temps      */
  65 static errmask_t check_access(char *, int *); /* check access to file   */
  66 static void whoami();                   /* gather information about me  */
  67 static void usage(void);                /* general usage                */
  68
  69
  70 /*
  71  * globals exported to the rest of the program
  72  */
  73 bool_t  opt_mtime;      /* preserve modification times on propagations  */
  74 bool_t  opt_notouch;    /* don't actually make any changes              */
  75 bool_t  opt_quiet;      /* disable reconciliation command output        */
  76 bool_t  opt_verbose;    /* enable analysis descriptions                 */
  77 side_t  opt_force;      /* designated winner for conflicts              */
  78 side_t  opt_oneway;     /* one way only propagation                     */
  79 side_t  opt_onesided;   /* permit one-sided evaluation                  */
  80 bool_t  opt_everything; /* everything must agree (modes/uid/gid)        */
  81 bool_t  opt_yes;        /* pre-confirm massive deletions are OK         */
  82 bool_t  opt_acls;       /* always scan for acls on all files            */
  83 bool_t  opt_errors;     /* simulate errors on specified files           */
  84 bool_t  opt_halt;       /* halt on propagation errors                   */
  85 dbgmask_t opt_debug;    /* debug mask                                   */
  86
  87 uid_t   my_uid;         /* default UID for files I create               */
  88 gid_t   my_gid;         /* default GID for files I create               */
  89
  90 static char *file_rules; /* name of rules file                          */
  91 static char *file_base; /* name of baseline file                        */
  92
  93 static int new_baseline; /* are we creating a new baseline              */
  94 static int new_rules;   /* are we creating a new rules file             */
  95 static int my_umask;    /* default UMASK for files I create             */
  96 static int lockfd;      /* file descriptor for locking baseline         */
  97
  98 static char *rlist[MAX_RLIST];
  99 static int num_restrs = 0;
 100
 101 /*
 102  * routine:
 103  *      main
 104  *
 105  * purpose:
 106  *      argument processing and primary dispatch
 107  *
 108  * returns:
 109  *      error codes per filesync.1 (ERR_* in filesync.h)
 110  *
 111  * notes:
 112  *      read filesync.1 in order to understand the argument processing
 113  *
 114  *      most of the command line options just set some opt_ global
 115  *      variable that is later looked at by the code that actually
 116  *      implements the features.  Only file names are really processed
 117  *      in this routine.
 118  */
 119 int
 120 main(int argc, char **argv)
 121 {       int i;
 122         int c;
 123         errmask_t errs = ERR_OK;
 124         int do_prune = 0;
 125         char *srcname = 0;
 126         char *dstname = 0;
 127         struct base *bp;
 128
 129         /* keep the error messages simple       */
 130         argv[0] = "filesync";
 131
 132         /* gather together all of the options   */
 133         while ((c = getopt(argc, argv, "AaehmnqvyD:E:r:s:d:f:o:")) != EOF)
 134                 switch (c) {
 135                         case 'a':       /* always scan for acls */
 136                                 opt_acls = TRUE;
 137                                 break;
 138                         case 'e':       /* everything agrees    */
 139                                 opt_everything = TRUE;
 140                                 break;
 141                         case 'h':       /* halt on error        */
 142                                 opt_halt = TRUE;
 143                                 break;
 144                         case 'm':       /* preserve modtimes    */
 145                                 opt_mtime = TRUE;
 146                                 break;
 147                         case 'n':       /* notouch              */
 148                                 opt_notouch = TRUE;
 149                                 break;
 150                         case 'q':       /* quiet                */
 151                                 opt_quiet = TRUE;
 152                                 break;
 153                         case 'v':       /* verbose              */
 154                                 opt_verbose = TRUE;
 155                                 break;
 156                         case 'y':       /* yes                  */
 157                                 opt_yes = TRUE;
 158                                 break;
 159                         case 'D':       /* debug options        */
 160                                 if (!isdigit(optarg[0])) {
 161                                         dbg_usage();
 162                                         exit(ERR_INVAL);
 163                                 }
 164                                 opt_debug |= strtol(optarg, (char **)NULL, 0);
 165                                 break;
 166
 167                         case 'E':       /* error simulation     */
 168                                 if (dbg_set_error(optarg)) {
 169                                         err_usage();
 170                                         exit(ERR_INVAL);
 171                                 }
 172                                 opt_errors = TRUE;
 173                                 break;
 174
 175                         case 'f':       /* force conflict resolution    */
 176                                 switch (optarg[0]) {
 177                                         case 's':
 178                                                 opt_force = OPT_SRC;
 179                                                 break;
 180                                         case 'd':
 181                                                 opt_force = OPT_DST;
 182                                                 break;
 183                                         case 'o':
 184                                                 opt_force = OPT_OLD;
 185                                                 break;
 186                                         case 'n':
 187                                                 opt_force = OPT_NEW;
 188                                                 break;
 189                                         default:
 190                                                 fprintf(stderr,
 191                                                         gettext(ERR_badopt),
 192                                                         c, optarg);
 193                                                 errs |= ERR_INVAL;
 194                                                 break;
 195                                 }
 196                                 break;
 197
 198                         case 'o':       /* one way propagation          */
 199                                 switch (optarg[0]) {
 200                                         case 's':
 201                                                 opt_oneway = OPT_SRC;
 202                                                 break;
 203                                         case 'd':
 204                                                 opt_oneway = OPT_DST;
 205                                                 break;
 206                                         default:
 207                                                 fprintf(stderr,
 208                                                         gettext(ERR_badopt),
 209                                                         c, optarg);
 210                                                 errs |= ERR_INVAL;
 211                                                 break;
 212                                 }
 213                                 break;
 214
 215                         case 'r':       /* restricted reconciliation    */
 216                                 if (num_restrs < MAX_RLIST)
 217                                         rlist[ num_restrs++ ] = optarg;
 218                                 else {
 219                                         fprintf(stderr, gettext(ERR_tomany),
 220                                                 MAX_RLIST);
 221                                         errs |= ERR_INVAL;
 222                                 }
 223                                 break;
 224
 225                         case 's':
 226                                 if ((srcname = qualify(optarg)) == 0)
 227                                         errs |= ERR_MISSING;
 228                                 break;
 229
 230                         case 'd':
 231                                 if ((dstname = qualify(optarg)) == 0)
 232                                         errs |= ERR_MISSING;
 233                                 break;
 234
 235                         default:
 236                         case '?':
 237                                 errs |= ERR_INVAL;
 238                                 break;
 239                 }
 240
 241         if (opt_debug & DBG_MISC)
 242                 fprintf(stderr, "MISC: DBG=%s\n", showflags(dbgmap, opt_debug));
 243
 244         /* if we have file names, we need a source and destination */
 245         if (optind < argc) {
 246                 if (srcname == 0) {
 247                         fprintf(stderr, gettext(ERR_nosrc));
 248                         errs |= ERR_INVAL;
 249                 }
 250                 if (dstname == 0) {
 251                         fprintf(stderr, gettext(ERR_nodst));
 252                         errs |= ERR_INVAL;
 253                 }
 254         }
 255
 256         /* check for simple usage errors        */
 257         if (errs & ERR_INVAL) {
 258                 usage();
 259                 exit(errs);
 260         }
 261
 262         /* locate our baseline and rules files  */
 263         if (c = findfiles())
 264                 exit(c);
 265
 266         /* figure out file creation defaults    */
 267         whoami();
 268
 269         /* read in our initial baseline         */
 270         if (!new_baseline && (c = read_baseline(file_base)))
 271                 errs |= c;
 272
 273         /* read in the rules file if we need or have rules      */
 274         if (optind >= argc && new_rules) {
 275                 fprintf(stderr, ERR_nonames);
 276                 errs |= ERR_INVAL;
 277         } else if (!new_rules)
 278                 errs |= read_rules(file_rules);
 279
 280         /* if anything has failed with our setup, go no further */
 281         if (errs) {
 282                 cleanup(errs);
 283                 exit(errs);
 284         }
 285
 286         /*
 287          * figure out whether or not we are willing to do a one-sided
 288          * analysis (where we don't even look at the other side.  This
 289          * is an "I'm just curious what has changed" query, and we are
 290          * only willing to do it if:
 291          *      we aren't actually going to do anything
 292          *      we have a baseline we can compare against
 293          * otherwise, we are going to insist on being able to access
 294          * both the source and destination.
 295          */
 296         if (opt_notouch && !new_baseline)
 297                 opt_onesided = opt_oneway;
 298
 299         /*
 300          * there are two interested usage scenarios:
 301          *      file names specified
 302          *              create new rules for the specified files
 303          *              evaulate and reconcile only the specified files
 304          *      no file names specified
 305          *              use already existing rules
 306          *              consider restricting them to specified subdirs/files
 307          */
 308         if (optind < argc) {
 309                 /* figure out what base pair we're working on   */
 310                 bp = add_base(srcname, dstname);
 311
 312                 /* perverse default rules to avoid trouble      */
 313                 if (new_rules) {
 314                         errs |= add_ignore(0, SUFX_RULES);
 315                         errs |= add_ignore(0, SUFX_BASE);
 316                 }
 317
 318                 /* create include rules for each file/dir arg   */
 319                 while (optind < argc)
 320                         errs |= add_include(bp, argv[ optind++ ]);
 321
 322                 /*
 323                  * evaluate the specified base on each side,
 324                  * being careful to limit evaulation to new rules
 325                  */
 326                 errs |= evaluate(bp, OPT_SRC, TRUE);
 327                 errs |= evaluate(bp, OPT_DST, TRUE);
 328         } else {
 329                 /* note any possible evaluation restrictions    */
 330                 for (i = 0; i < num_restrs; i++)
 331                         errs |= add_restr(rlist[i]);
 332
 333                 /*
 334                  * we can only prune the baseline file if we have done
 335                  * a complete (unrestricted) analysis.
 336                  */
 337                 if (i == 0)
 338                         do_prune = 1;
 339
 340                 /* evaulate each base on each side              */
 341                 for (bp = bases; bp; bp = bp->b_next) {
 342                         errs |= evaluate(bp, OPT_SRC, FALSE);
 343                         errs |= evaluate(bp, OPT_DST, FALSE);
 344                 }
 345         }
 346
 347         /* if anything serious happened, skip reconciliation    */
 348         if (errs & ERR_FATAL) {
 349                 cleanup(errs);
 350                 exit(errs);
 351         }
 352
 353         /* analyze and deal with the differenecs                */
 354         errs |= analyze();
 355
 356         /* see if there is any dead-wood in the baseline        */
 357         if (do_prune) {
 358                 c = prune();
 359
 360                 if (c > 0 && opt_verbose)
 361                         fprintf(stdout, V_prunes, c);
 362         }
 363
 364         /* print out a final summary                            */
 365         summary();
 366
 367         /* update the rules and baseline files (if needed)      */
 368         (void) umask(my_umask);
 369         errs |= write_baseline(file_base);
 370         errs |= write_rules(file_rules);
 371
 372         if (opt_debug & DBG_MISC)
 373                 fprintf(stderr, "MISC: EXIT=%s\n", showflags(errmap, errs));
 374
 375         /* just returning ERR_RESOLVABLE upsets some people     */
 376         if (errs == ERR_RESOLVABLE && !opt_notouch)
 377                 errs = 0;
 378
 379         /* all done     */
 380         cleanup(0);
 381         return (errs);
 382 }
 383
 384
 385 /*
 386  * routine:
 387  *      usage
 388  *
 389  * purpose:
 390  *      print out a usage message
 391  *
 392  * parameters:
 393  *      none
 394  *
 395  * returns:
 396  *      none
 397  *
 398  * note:
 399  *      the -D and -E switches are for development/test/support
 400  *      use only and do not show up in the general usage message.
 401  */
 402 static void
 403 usage(void)
 404 {
 405         fprintf(stderr, "%s\t%s %s\n", gettext(ERR_usage), "filesync",
 406                                         gettext(USE_simple));
 407         fprintf(stderr, "\t%s %s\n", "filesync", gettext(USE_all));
 408         fprintf(stderr, "\t-a .......... %s\n", gettext(USE_a));
 409         fprintf(stderr, "\t-e .......... %s\n", gettext(USE_e));
 410         fprintf(stderr, "\t-h .......... %s\n", gettext(USE_h));
 411         fprintf(stderr, "\t-m .......... %s\n", gettext(USE_m));
 412         fprintf(stderr, "\t-n .......... %s\n", gettext(USE_n));
 413         fprintf(stderr, "\t-q .......... %s\n", gettext(USE_q));
 414         fprintf(stderr, "\t-v .......... %s\n", gettext(USE_v));
 415         fprintf(stderr, "\t-y .......... %s\n", gettext(USE_y));
 416         fprintf(stderr, "\t-s dir ...... %s\n", gettext(USE_s));
 417         fprintf(stderr, "\t-d dir ...... %s\n", gettext(USE_d));
 418         fprintf(stderr, "\t-r dir ...... %s\n", gettext(USE_r));
 419         fprintf(stderr, "\t-f [sdon].... %s\n", gettext(USE_f));
 420         fprintf(stderr, "\t-o src/dst... %s\n", gettext(USE_o));
 421 }
 422
 423 /*
 424  * routine:
 425  *      confirm
 426  *
 427  * purpose:
 428  *      to confirm that the user is willing to do something dangerous
 429  *
 430  * parameters:
 431  *      warning message to be printed
 432  *
 433  * returns:
 434  *      void
 435  *
 436  * notes:
 437  *      if this is a "notouch" or if the user has pre-confirmed,
 438  *      we should not obtain the confirmation and just return that
 439  *      the user has confirmed.
 440  */
 441 void
 442 confirm(char *message)
 443 {       FILE *ttyi, *ttyo;
 444         char ansbuf[ MAX_LINE ];
 445
 446         /* if user pre-confirmed, we don't have to ask  */
 447         if (opt_yes || opt_notouch)
 448                 return;
 449
 450         ttyo = fopen("/dev/tty", "w");
 451         ttyi = fopen("/dev/tty", "r");
 452         if (ttyi == NULL || ttyo == NULL)
 453                 exit(ERR_OTHER);
 454
 455         /* explain the problem and prompt for confirmation      */
 456         fprintf(ttyo, message);
 457         fprintf(ttyo, gettext(WARN_proceed));
 458
 459         /* if the user doesn't kill us, we can continue         */
 460         (void) fgets(ansbuf, sizeof (ansbuf), ttyi);
 461
 462         /* close the files and return                           */
 463         (void) fclose(ttyi);
 464         (void) fclose(ttyo);
 465 }
 466
 467 void
 468 nomem(char *reason)
 469 {
 470         fprintf(stderr, gettext(ERR_nomem), reason);
 471         exit(ERR_OTHER);
 472 }
 473
 474 /*
 475  * routine:
 476  *      findfiles
 477  *
 478  * purpose:
 479  *      to locate our baseline and rules files
 480  *
 481  * parameters:
 482  *      none
 483  *
 484  * returns:
 485  *      error mask
 486  *      settings of file_base and file_rules
 487  *
 488  * side-effects:
 489  *      in order to keep multiple filesyncs from running in parallel
 490  *      we put an advisory lock on the baseline file.  If the baseline
 491  *      file does not exist we create one.  The unlocking (and deletion
 492  *      of extraneous baselines) is handled in cleanup.
 493  */
 494 static errmask_t
 495 findfiles(void)         /* find rule and baseline files */
 496 {       char *s, *where;
 497         char namebuf[MAX_PATH];
 498         int ret;
 499         errmask_t errs = 0;
 500
 501         /* figure out where the files should be located */
 502         s = getenv("FILESYNC");
 503         where = (s && *s) ? expand(s) : expand(DFLT_PRFX);
 504
 505         /* see if we got a viable name          */
 506         if (where == 0) {
 507                 fprintf(stderr, gettext(ERR_nofsync));
 508                 return (ERR_FILES);
 509         }
 510
 511         /* try to form the name of the rules file */
 512         strcpy(namebuf, where);
 513         strcat(namebuf, SUFX_RULES);
 514         s = strdup(namebuf);
 515         errs = check_access(namebuf, &new_rules);
 516
 517         /* if we cannot find a proper rules file, look in the old place */
 518         if (new_rules && errs == 0) {
 519                 strcpy(namebuf, where);
 520                 strcat(namebuf, SUFX_OLD);
 521                 file_rules = strdup(namebuf);
 522                 errs = check_access(namebuf, &new_rules);
 523
 524                 /* if we couldn't find that either, go with new name    */
 525                 if (new_rules && errs == 0)
 526                         file_rules = s;
 527         } else
 528                 file_rules = s;
 529
 530         /* try to form the name of the baseline file */
 531         strcpy(namebuf, where);
 532         strcat(namebuf, SUFX_BASE);
 533         file_base = strdup(namebuf);
 534         errs |= check_access(namebuf, &new_baseline);
 535
 536         if (opt_debug & DBG_FILES) {
 537                 fprintf(stderr, "FILE: %s rules file: %s\n",
 538                         new_rules ? "new" : "existing", file_rules);
 539
 540                 fprintf(stderr, "FILE: %s base file:  %s\n",
 541                         new_baseline ? "new" : "existing", file_base);
 542         }
 543
 544         /*
 545          * in order to lock out other filesync programs we need some
 546          * file we can lock.  We do an advisory lock on the baseline
 547          * file.  If no baseline file exists, we create an empty one.
 548          */
 549         if (new_baseline)
 550                 lockfd = creat(file_base, 0666);
 551         else
 552                 lockfd = open(file_base, O_RDWR);
 553
 554         if (lockfd < 0) {
 555                 fprintf(stderr, new_baseline ? ERR_creat : ERR_open,
 556                         TXT_base, file_base);
 557                 errs |= ERR_FILES;
 558         } else {
 559                 ret = lockf(lockfd, F_TLOCK, 0L);
 560                 if (ret < 0) {
 561                         fprintf(stderr, ERR_lock, TXT_base, file_base);
 562                         errs |= ERR_FILES;
 563                 } else if (opt_debug & DBG_FILES)
 564                         fprintf(stderr, "FILE: locking baseline file %s\n",
 565                                 file_base);
 566         }
 567
 568         return (errs);
 569 }
 570
 571 /*
 572  * routine:
 573  *      cleanup
 574  *
 575  * purpose:
 576  *      to clean up temporary files and locking prior to exit
 577  *
 578  * paremeters:
 579  *      error mask
 580  *
 581  * returns:
 582  *      void
 583  *
 584  * notes:
 585  *      if there are no errors, the baseline file is assumed to be good.
 586  *      Otherwise, if we created a temporary baseline file (just for
 587  *      locking) we will delete it.
 588  */
 589 static void
 590 cleanup(errmask_t errmask)
 591 {
 592         /* unlock the baseline file     */
 593         if (opt_debug & DBG_FILES)
 594                 fprintf(stderr, "FILE: unlock baseline file %s\n", file_base);
 595         (void) lockf(lockfd, F_ULOCK, 0);
 596
 597         /* see if we need to delete a temporary copy    */
 598         if (errmask && new_baseline) {
 599                 if (opt_debug & DBG_FILES)
 600                         fprintf(stderr, "FILE: unlink temp baseline file %s\n",
 601                                 file_base);
 602                 (void) unlink(file_base);
 603         }
 604 }
 605
 606 /*
 607  * routine:
 608  *      check_access
 609  *
 610  * purpose:
 611  *      to determine whether or not we can access an existing file
 612  *      or create a new one
 613  *
 614  * parameters:
 615  *      name of file (in a clobberable buffer)
 616  *      pointer to new file flag
 617  *
 618  * returns:
 619  *      error mask
 620  *      setting of the new file flag
 621  *
 622  * note:
 623  *      it is kind of a kluge that this routine clobbers the name,
 624  *      but it is only called from one place, it needs a modified
 625  *      copy of the name, and the one caller doesn't mind.
 626  */
 627 static errmask_t
 628 check_access(char *name, int *newflag)
 629 {       char *s;
 630
 631         /* start out by asking for what we want         */
 632         if (access(name, R_OK|W_OK) == 0) {
 633                 *newflag = 0;
 634                 return (0);
 635         }
 636
 637         /* if the problem is isn't non-existence, lose  */
 638         if (errno != ENOENT) {
 639                 *newflag = 0;
 640                 fprintf(stderr, gettext(ERR_rdwri), name);
 641                 return (ERR_FILES);
 642         }
 643
 644         /*
 645          * the file doesn't exist, so there is still hope if we can
 646          * write in the directory that should contain the file
 647          */
 648         *newflag = 1;
 649
 650         /* truncate the file name to its containing directory */
 651         for (s = name; s[1]; s++);
 652         while (s > name && *s != '/')
 653                 s--;
 654         if (s > name)
 655                 *s = 0;
 656         else if (*s == '/')
 657                 s[1] = 0;
 658         else
 659                 name = ".";
 660
 661         /* then see if we have write access to the directory    */
 662         if (access(name, W_OK) == 0)
 663                 return (0);
 664
 665         fprintf(stderr, gettext(ERR_dirwac), name);
 666         return (ERR_FILES);
 667 }
 668
 669 /*
 670  * routine:
 671  *      whoami
 672  *
 673  * purpose:
 674  *      to figure out who I am and what the default modes/ownership
 675  *      is on files that I create.
 676  */
 677 static void
 678 whoami()
 679 {
 680         my_uid = geteuid();
 681         my_gid = getegid();
 682         my_umask = umask(0);
 683
 684         if (opt_debug & DBG_MISC)
 685                 fprintf(stderr, "MISC: my_uid=%u, my_gid=%u, my_umask=%03o\n",
 686                         my_uid, my_gid, my_umask);
 687 }