static void write_new_colors(FILE * fd, struct Colors *colors) { char str1[100], str2[100]; format_min(str1, (double)colors->cmin); format_max(str2, (double)colors->cmax); fprintf(fd, "%% %s %s\n", str1, str2); if (colors->shift) { sprintf(str2, "%.15g", (double)colors->shift); G_trim_decimal(str2); fprintf(fd, "shift:%s\n", str2); } if (colors->invert) fprintf(fd, "invert\n"); if (colors->null_set) { fprintf(fd, "nv:%d", colors->null_red); if (colors->null_red != colors->null_grn || colors->null_red != colors->null_blu) fprintf(fd, ":%d:%d", colors->null_grn, colors->null_blu); fprintf(fd, "\n"); } if (colors->undef_set) { fprintf(fd, "*:%d", colors->undef_red); if (colors->undef_red != colors->undef_grn || colors->undef_red != colors->undef_blu) fprintf(fd, ":%d:%d", colors->undef_grn, colors->undef_blu); fprintf(fd, "\n"); } if (colors->modular.rules) { fprintf(fd, "%s\n", "%%"); write_rules(fd, colors->modular.rules, colors->cmin, colors->cmax); fprintf(fd, "%s\n", "%%"); } if (colors->fixed.rules) write_rules(fd, colors->fixed.rules, colors->cmin, colors->cmax); }
/* * 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); }