/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * module: * main.c * * purpose: * argument handling and top level dispatch * * contents: * main argument handling and main loop * usage (static) print out usage message * confirm prompt the user for a confirmation and get it * nomem fatal error handler for malloc failures * findfiles (static) locate our baseline and rules files * cleanup (static) unlock baseline and delete temp file * check_access (static) do we have adequate access to a file/directory * whoami (static) get uid/gid/umask */ #include <unistd.h> #include <stdlib.h> #include <fcntl.h> #include <stdio.h> #include <string.h> #include <ctype.h> #include <errno.h> #include <sys/stat.h> #include "filesync.h" #include "database.h" #include "messages.h" #include "debug.h" /* * local routines in this module: */ static errmask_t findfiles(); /* find rule and baseline files */ static void cleanup(int); /* cleanup locks and temps */ static errmask_t check_access(char *, int *); /* check access to file */ static void whoami(); /* gather information about me */ static void usage(void); /* general usage */ /* * globals exported to the rest of the program */ bool_t opt_mtime; /* preserve modification times on propagations */ bool_t opt_notouch; /* don't actually make any changes */ bool_t opt_quiet; /* disable reconciliation command output */ bool_t opt_verbose; /* enable analysis descriptions */ side_t opt_force; /* designated winner for conflicts */ side_t opt_oneway; /* one way only propagation */ side_t opt_onesided; /* permit one-sided evaluation */ bool_t opt_everything; /* everything must agree (modes/uid/gid) */ bool_t opt_yes; /* pre-confirm massive deletions are OK */ bool_t opt_acls; /* always scan for acls on all files */ bool_t opt_errors; /* simulate errors on specified files */ bool_t opt_halt; /* halt on propagation errors */ dbgmask_t opt_debug; /* debug mask */ uid_t my_uid; /* default UID for files I create */ gid_t my_gid; /* default GID for files I create */ static char *file_rules; /* name of rules file */ static char *file_base; /* name of baseline file */ static int new_baseline; /* are we creating a new baseline */ static int new_rules; /* are we creating a new rules file */ static int my_umask; /* default UMASK for files I create */ static int lockfd; /* file descriptor for locking baseline */ static char *rlist[MAX_RLIST]; static int num_restrs = 0; /* * routine: * main * * purpose: * argument processing and primary dispatch * * returns: * error codes per filesync.1 (ERR_* in filesync.h) * * notes: * read filesync.1 in order to understand the argument processing * * most of the command line options just set some opt_ global * variable that is later looked at by the code that actually * implements the features. Only file names are really processed * in this routine. */ int main(int argc, char **argv) { int i; int c; errmask_t errs = ERR_OK; int do_prune = 0; char *srcname = 0; char *dstname = 0; struct base *bp; /* keep the error messages simple */ argv[0] = "filesync"; /* gather together all of the options */ while ((c = getopt(argc, argv, "AaehmnqvyD:E:r:s:d:f:o:")) != EOF) switch (c) { case 'a': /* always scan for acls */ opt_acls = TRUE; break; case 'e': /* everything agrees */ opt_everything = TRUE; break; case 'h': /* halt on error */ opt_halt = TRUE; break; case 'm': /* preserve modtimes */ opt_mtime = TRUE; break; case 'n': /* notouch */ opt_notouch = TRUE; break; case 'q': /* quiet */ opt_quiet = TRUE; break; case 'v': /* verbose */ opt_verbose = TRUE; break; case 'y': /* yes */ opt_yes = TRUE; break; case 'D': /* debug options */ if (!isdigit(optarg[0])) { dbg_usage(); exit(ERR_INVAL); } opt_debug |= strtol(optarg, (char **)NULL, 0); break; case 'E': /* error simulation */ if (dbg_set_error(optarg)) { err_usage(); exit(ERR_INVAL); } opt_errors = TRUE; break; case 'f': /* force conflict resolution */ switch (optarg[0]) { case 's': opt_force = OPT_SRC; break; case 'd': opt_force = OPT_DST; break; case 'o': opt_force = OPT_OLD; break; case 'n': opt_force = OPT_NEW; break; default: fprintf(stderr, gettext(ERR_badopt), c, optarg); errs |= ERR_INVAL; break; } break; case 'o': /* one way propagation */ switch (optarg[0]) { case 's': opt_oneway = OPT_SRC; break; case 'd': opt_oneway = OPT_DST; break; default: fprintf(stderr, gettext(ERR_badopt), c, optarg); errs |= ERR_INVAL; break; } break; case 'r': /* restricted reconciliation */ if (num_restrs < MAX_RLIST) rlist[ num_restrs++ ] = optarg; else { fprintf(stderr, gettext(ERR_tomany), MAX_RLIST); errs |= ERR_INVAL; } break; case 's': if ((srcname = qualify(optarg)) == 0) errs |= ERR_MISSING; break; case 'd': if ((dstname = qualify(optarg)) == 0) errs |= ERR_MISSING; break; default: case '?': errs |= ERR_INVAL; break; } if (opt_debug & DBG_MISC) fprintf(stderr, "MISC: DBG=%s\n", showflags(dbgmap, opt_debug)); /* if we have file names, we need a source and destination */ if (optind < argc) { if (srcname == 0) { fprintf(stderr, gettext(ERR_nosrc)); errs |= ERR_INVAL; } if (dstname == 0) { fprintf(stderr, gettext(ERR_nodst)); errs |= ERR_INVAL; } } /* check for simple usage errors */ if (errs & ERR_INVAL) { usage(); exit(errs); } /* locate our baseline and rules files */ if (c = findfiles()) exit(c); /* figure out file creation defaults */ whoami(); /* read in our initial baseline */ if (!new_baseline && (c = read_baseline(file_base))) errs |= c; /* read in the rules file if we need or have rules */ if (optind >= argc && new_rules) { fprintf(stderr, ERR_nonames); errs |= ERR_INVAL; } else if (!new_rules) errs |= read_rules(file_rules); /* if anything has failed with our setup, go no further */ if (errs) { cleanup(errs); exit(errs); } /* * figure out whether or not we are willing to do a one-sided * analysis (where we don't even look at the other side. This * is an "I'm just curious what has changed" query, and we are * only willing to do it if: * we aren't actually going to do anything * we have a baseline we can compare against * otherwise, we are going to insist on being able to access * both the source and destination. */ if (opt_notouch && !new_baseline) opt_onesided = opt_oneway; /* * there are two interested usage scenarios: * file names specified * create new rules for the specified files * evaulate and reconcile only the specified files * no file names specified * use already existing rules * consider restricting them to specified subdirs/files */ if (optind < argc) { /* figure out what base pair we're working on */ bp = add_base(srcname, dstname); /* perverse default rules to avoid trouble */ if (new_rules) { errs |= add_ignore(0, SUFX_RULES); errs |= add_ignore(0, SUFX_BASE); } /* create include rules for each file/dir arg */ while (optind < argc) errs |= add_include(bp, argv[ optind++ ]); /* * evaluate the specified base on each side, * being careful to limit evaulation to new rules */ errs |= evaluate(bp, OPT_SRC, TRUE); errs |= evaluate(bp, OPT_DST, TRUE); } else { /* note any possible evaluation restrictions */ for (i = 0; i < num_restrs; i++) errs |= add_restr(rlist[i]); /* * we can only prune the baseline file if we have done * a complete (unrestricted) analysis. */ if (i == 0) do_prune = 1; /* evaulate each base on each side */ for (bp = bases; bp; bp = bp->b_next) { errs |= evaluate(bp, OPT_SRC, FALSE); errs |= evaluate(bp, OPT_DST, FALSE); } } /* if anything serious happened, skip reconciliation */ if (errs & ERR_FATAL) { cleanup(errs); exit(errs); } /* analyze and deal with the differenecs */ errs |= analyze(); /* see if there is any dead-wood in the baseline */ if (do_prune) { c = prune(); if (c > 0 && opt_verbose) fprintf(stdout, V_prunes, c); } /* print out a final summary */ summary(); /* update the rules and baseline files (if needed) */ (void) umask(my_umask); errs |= write_baseline(file_base); errs |= write_rules(file_rules); if (opt_debug & DBG_MISC) fprintf(stderr, "MISC: EXIT=%s\n", showflags(errmap, errs)); /* just returning ERR_RESOLVABLE upsets some people */ if (errs == ERR_RESOLVABLE && !opt_notouch) errs = 0; /* all done */ cleanup(0); return (errs); } /* * routine: * usage * * purpose: * print out a usage message * * parameters: * none * * returns: * none * * note: * the -D and -E switches are for development/test/support * use only and do not show up in the general usage message. */ static void usage(void) { fprintf(stderr, "%s\t%s %s\n", gettext(ERR_usage), "filesync", gettext(USE_simple)); fprintf(stderr, "\t%s %s\n", "filesync", gettext(USE_all)); fprintf(stderr, "\t-a .......... %s\n", gettext(USE_a)); fprintf(stderr, "\t-e .......... %s\n", gettext(USE_e)); fprintf(stderr, "\t-h .......... %s\n", gettext(USE_h)); fprintf(stderr, "\t-m .......... %s\n", gettext(USE_m)); fprintf(stderr, "\t-n .......... %s\n", gettext(USE_n)); fprintf(stderr, "\t-q .......... %s\n", gettext(USE_q)); fprintf(stderr, "\t-v .......... %s\n", gettext(USE_v)); fprintf(stderr, "\t-y .......... %s\n", gettext(USE_y)); fprintf(stderr, "\t-s dir ...... %s\n", gettext(USE_s)); fprintf(stderr, "\t-d dir ...... %s\n", gettext(USE_d)); fprintf(stderr, "\t-r dir ...... %s\n", gettext(USE_r)); fprintf(stderr, "\t-f [sdon].... %s\n", gettext(USE_f)); fprintf(stderr, "\t-o src/dst... %s\n", gettext(USE_o)); } /* * routine: * confirm * * purpose: * to confirm that the user is willing to do something dangerous * * parameters: * warning message to be printed * * returns: * void * * notes: * if this is a "notouch" or if the user has pre-confirmed, * we should not obtain the confirmation and just return that * the user has confirmed. */ void confirm(char *message) { FILE *ttyi, *ttyo; char ansbuf[ MAX_LINE ]; /* if user pre-confirmed, we don't have to ask */ if (opt_yes || opt_notouch) return; ttyo = fopen("/dev/tty", "w"); ttyi = fopen("/dev/tty", "r"); if (ttyi == NULL || ttyo == NULL) exit(ERR_OTHER); /* explain the problem and prompt for confirmation */ fprintf(ttyo, message); fprintf(ttyo, gettext(WARN_proceed)); /* if the user doesn't kill us, we can continue */ (void) fgets(ansbuf, sizeof (ansbuf), ttyi); /* close the files and return */ (void) fclose(ttyi); (void) fclose(ttyo); } void nomem(char *reason) { fprintf(stderr, gettext(ERR_nomem), reason); exit(ERR_OTHER); } /* * routine: * findfiles * * purpose: * to locate our baseline and rules files * * parameters: * none * * returns: * error mask * settings of file_base and file_rules * * side-effects: * in order to keep multiple filesyncs from running in parallel * we put an advisory lock on the baseline file. If the baseline * file does not exist we create one. The unlocking (and deletion * of extraneous baselines) is handled in cleanup. */ static errmask_t findfiles(void) /* find rule and baseline files */ { char *s, *where; char namebuf[MAX_PATH]; int ret; errmask_t errs = 0; /* figure out where the files should be located */ s = getenv("FILESYNC"); where = (s && *s) ? expand(s) : expand(DFLT_PRFX); /* see if we got a viable name */ if (where == 0) { fprintf(stderr, gettext(ERR_nofsync)); return (ERR_FILES); } /* try to form the name of the rules file */ strcpy(namebuf, where); strcat(namebuf, SUFX_RULES); s = strdup(namebuf); errs = check_access(namebuf, &new_rules); /* if we cannot find a proper rules file, look in the old place */ if (new_rules && errs == 0) { strcpy(namebuf, where); strcat(namebuf, SUFX_OLD); file_rules = strdup(namebuf); errs = check_access(namebuf, &new_rules); /* if we couldn't find that either, go with new name */ if (new_rules && errs == 0) file_rules = s; } else file_rules = s; /* try to form the name of the baseline file */ strcpy(namebuf, where); strcat(namebuf, SUFX_BASE); file_base = strdup(namebuf); errs |= check_access(namebuf, &new_baseline); if (opt_debug & DBG_FILES) { fprintf(stderr, "FILE: %s rules file: %s\n", new_rules ? "new" : "existing", file_rules); fprintf(stderr, "FILE: %s base file: %s\n", new_baseline ? "new" : "existing", file_base); } /* * in order to lock out other filesync programs we need some * file we can lock. We do an advisory lock on the baseline * file. If no baseline file exists, we create an empty one. */ if (new_baseline) lockfd = creat(file_base, 0666); else lockfd = open(file_base, O_RDWR); if (lockfd < 0) { fprintf(stderr, new_baseline ? ERR_creat : ERR_open, TXT_base, file_base); errs |= ERR_FILES; } else { ret = lockf(lockfd, F_TLOCK, 0L); if (ret < 0) { fprintf(stderr, ERR_lock, TXT_base, file_base); errs |= ERR_FILES; } else if (opt_debug & DBG_FILES) fprintf(stderr, "FILE: locking baseline file %s\n", file_base); } return (errs); } /* * routine: * cleanup * * purpose: * to clean up temporary files and locking prior to exit * * paremeters: * error mask * * returns: * void * * notes: * if there are no errors, the baseline file is assumed to be good. * Otherwise, if we created a temporary baseline file (just for * locking) we will delete it. */ static void cleanup(errmask_t errmask) { /* unlock the baseline file */ if (opt_debug & DBG_FILES) fprintf(stderr, "FILE: unlock baseline file %s\n", file_base); (void) lockf(lockfd, F_ULOCK, 0); /* see if we need to delete a temporary copy */ if (errmask && new_baseline) { if (opt_debug & DBG_FILES) fprintf(stderr, "FILE: unlink temp baseline file %s\n", file_base); (void) unlink(file_base); } } /* * routine: * check_access * * purpose: * to determine whether or not we can access an existing file * or create a new one * * parameters: * name of file (in a clobberable buffer) * pointer to new file flag * * returns: * error mask * setting of the new file flag * * note: * it is kind of a kluge that this routine clobbers the name, * but it is only called from one place, it needs a modified * copy of the name, and the one caller doesn't mind. */ static errmask_t check_access(char *name, int *newflag) { char *s; /* start out by asking for what we want */ if (access(name, R_OK|W_OK) == 0) { *newflag = 0; return (0); } /* if the problem is isn't non-existence, lose */ if (errno != ENOENT) { *newflag = 0; fprintf(stderr, gettext(ERR_rdwri), name); return (ERR_FILES); } /* * the file doesn't exist, so there is still hope if we can * write in the directory that should contain the file */ *newflag = 1; /* truncate the file name to its containing directory */ for (s = name; s[1]; s++); while (s > name && *s != '/') s--; if (s > name) *s = 0; else if (*s == '/') s[1] = 0; else name = "."; /* then see if we have write access to the directory */ if (access(name, W_OK) == 0) return (0); fprintf(stderr, gettext(ERR_dirwac), name); return (ERR_FILES); } /* * routine: * whoami * * purpose: * to figure out who I am and what the default modes/ownership * is on files that I create. */ static void whoami() { my_uid = geteuid(); my_gid = getegid(); my_umask = umask(0); if (opt_debug & DBG_MISC) fprintf(stderr, "MISC: my_uid=%u, my_gid=%u, my_umask=%03o\n", my_uid, my_gid, my_umask); }
