embedaddon/rsync/options.c - diff

Return to options.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/options.c between versions 1.1 and 1.1.1.4

-version 1.1, 2012/02/17 15:09:30
+version 1.1.1.4, 2021/03/17 00:32:36
  Line 3
   *
   * Copyright (C) 1998-2001 Andrew Tridgell <tridge@samba.org>
   * Copyright (C) 2000, 2001, 2002 Martin Pool <mbp@samba.org>
- * Copyright (C) 2002-2011 Wayne Davison
+ * Copyright (C) 2002-2020 Wayne Davison
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
  Line 20
   */
  #include "rsync.h"
+ #include "itypes.h"
  #include "ifuncs.h"
  #include <popt.h>
- #include "zlib/zlib.h"
+ extern int direct_io;
  extern int module_id;
  extern int local_server;
  extern int sanitize_paths;
- extern int daemon_over_rsh;
  extern unsigned int module_dirlen;
-extern struct filter_list_struct filter_list;
+extern filter_rule_list filter_list;
-extern struct filter_list_struct daemon_filter_list;
+extern filter_rule_list daemon_filter_list;
  int make_backups = 0;
+ int make_source_backups = 0;
  /**
   * If 1, send the whole file as literal data rather than trying to
- Line 48  int append_mode = 0;
+ Line 49  int append_mode = 0;
  int keep_dirlinks = 0;
  int copy_dirlinks = 0;
  int copy_links = 0;
+ int copy_devices = 0;
+ int write_devices = 0;
  int preserve_links = 0;
  int preserve_hard_links = 0;
  int preserve_acls = 0;
  int preserve_xattrs = 0;
+ int preserve_hfs_compression = 0;
  int preserve_perms = 0;
+ int preserve_fileflags = 0;
  int preserve_executability = 0;
  int preserve_devices = 0;
  int preserve_specials = 0;
  int preserve_uid = 0;
  int preserve_gid = 0;
  int preserve_times = 0;
+ int preserve_atimes = 0;
+ int preserve_crtimes = 0;
  int update_only = 0;
+ int downdate_only = 0;
+ int open_noatime = 0;
  int cvs_exclude = 0;
  int dry_run = 0;
  int do_xfers = 1;
+ int do_fsync = 0;
  int ignore_times = 0;
  int delete_mode = 0;
  int delete_during = 0;
  int delete_before = 0;
  int delete_after = 0;
  int delete_excluded = 0;
+ int diffserv = 8;
+ char *congestion_alg = NULL;
  int remove_source_files = 0;
+ int omit_dir_changes = 0;
  int one_file_system = 0;
  int protocol_version = PROTOCOL_VERSION;
  int sparse_files = 0;
+ long sparse_files_block_size = SPARSE_WRITE_SIZE;
+ int preallocate_files = 0;
  int do_compression = 0;
-int def_compress_level = Z_DEFAULT_COMPRESSION;
+int do_compression_level = CLVL_NOT_SPECIFIED;
  int am_root = 0; /* 0 = normal, 1 = root, 2 = --super, -1 = --fake-super */
  int am_server = 0;
  int am_sender = 0;
  int am_starting_up = 1;
+ int am_dbadmin = 0;
  int relative_paths = -1;
+ int detect_renamed = 0;
  int implied_dirs = 1;
+ int missing_args = 0; /* 0 = FERROR_XFER, 1 = ignore, 2 = delete */
  int numeric_ids = 0;
+ int msgs2stderr = 2; /* Default: send errors to stderr for local & remote-shell transfers */
  int allow_8bit_chars = 0;
  int force_delete = 0;
+ int force_change = 0;
  int io_timeout = 0;
  int prune_empty_dirs = 0;
  int use_qsort = 0;
  char *files_from = NULL;
  int filesfrom_fd = -1;
  char *filesfrom_host = NULL;
+ char *db_config = NULL;
  int eol_nulls = 0;
-int protect_args = 0;
+int protect_args = -1;
-int human_readable = 0;
+int human_readable = 1;
  int recurse = 0;
+ int mkpath_dest_arg = 0;
  int allow_inc_recurse = 1;
  int xfer_dirs = -1;
  int am_daemon = 0;
-int do_stats = 0;
+int db_clean, db_check, db_do_md4, db_do_md5, db_update = 1, db_lax, db_init, db_mounts;
-int do_progress = 0;
+int db_output_name, db_output_sum, db_output_info, db_output_unchanged, db_output_dirs, db_output_msgs;
+int saw_db_output_opt, saw_db_sum_opt;
  int connect_timeout = 0;
  int keep_partial = 0;
  int safe_symlinks = 0;
  int copy_unsafe_links = 0;
+ int munge_symlinks = 0;
  int size_only = 0;
+ int date_only = 0;
  int daemon_bwlimit = 0;
  int bwlimit = 0;
  int fuzzy_basis = 0;
+ unsigned long sleep_asec = 0;
  size_t bwlimit_writemax = 0;
  int ignore_existing = 0;
  int ignore_non_existing = 0;
  int need_messages_from_generator = 0;
+ int checksum_files = CSF_IGNORE_FILES;
  int max_delete = INT_MIN;
-OFF_T max_size = 0;
+OFF_T max_size = -1;
-OFF_T min_size = 0;
+OFF_T min_size = -1;
  int ignore_errors = 0;
  int modify_window = 0;
+ int ignore_case = 0;
  int blocking_io = -1;
  int checksum_seed = 0;
  int inplace = 0;
  int delay_updates = 0;
-long block_size = 0; /* "long" because popt can't set an int32. */
+int32 block_size = 0;
+time_t stop_at_utime = 0;
  char *skip_compress = NULL;
+ char *copy_as = NULL;
+ item_list dparam_list = EMPTY_ITEM_LIST;
  /** Network address family. **/
  int default_af_hint
- Line 148  int no_detach
+ Line 179  int no_detach
  int write_batch = 0;
  int read_batch = 0;
  int backup_dir_len = 0;
+ int backup_dir_dels_len = 0;
  int backup_suffix_len;
+ int backup_suffix_dels_len;
  unsigned int backup_dir_remainder;
+ unsigned int backup_dir_dels_remainder;
  char *backup_suffix = NULL;
+ char *backup_suffix_dels = NULL;
  char *tmpdir = NULL;
  char *partial_dir = NULL;
  char *basis_dir[MAX_BASIS_DIRS+1];
+ char *link_by_hash_dir = NULL;
  char *config_file = NULL;
  char *shell_cmd = NULL;
  char *logfile_name = NULL;
  char *logfile_format = NULL;
  char *stdout_format = NULL;
  char *password_file = NULL;
+ char *source_filter = NULL;
+ char *dest_filter = NULL;
+ char *early_input_file = NULL;
  char *rsync_path = RSYNC_PATH;
  char *backup_dir = NULL;
+ char *backup_dir_dels = NULL;
  char backup_dir_buf[MAXPATHLEN];
+ char backup_dir_dels_buf[MAXPATHLEN];
  char *sockopts = NULL;
+ char *usermap = NULL;
+ char *groupmap = NULL;
  int rsync_port = 0;
-int compare_dest = 0;
+int alt_dest_type = 0;
-int copy_dest = 0;
-int link_dest = 0;
  int basis_dir_cnt = 0;
- char *dest_option = NULL;
-int verbose = 0;
+#define DEFAULT_MAX_ALLOC (1024L * 1024 * 1024)
+size_t max_alloc = DEFAULT_MAX_ALLOC;
+char *max_alloc_arg;
+static int version_opt_cnt = 0;
+static int remote_option_alloc = 0;
+int remote_option_cnt = 0;
+const char **remote_options = NULL;
+const char *checksum_choice = NULL;
+const char *compress_choice = NULL;
  int quiet = 0;
  int output_motd = 1;
  int log_before_transfer = 0;
- Line 182  int logfile_format_has_i = 0;
+ Line 232  int logfile_format_has_i = 0;
  int logfile_format_has_o_or_i = 0;
  int always_checksum = 0;
  int list_only = 0;
+ char *tr_opt = NULL;
  #define MAX_BATCH_NAME_LEN 256  /* Must be less than MAXPATHLEN-13 */
  char *batch_name = NULL;
  int need_unsorted_flist = 0;
+ char *iconv_opt =
  #ifdef ICONV_OPTION
-char *iconv_opt = ICONV_OPTION;
+                ICONV_OPTION;
+#else
+                NULL;
  #endif
  struct chmod_mode_struct *chmod_modes = NULL;
+ static const char *debug_verbosity[] = {
+         /*0*/ NULL,
+         /*1*/ NULL,
+         /*2*/ "BIND,CMD,CONNECT,DEL,DELTASUM,DUP,FILTER,FLIST,ICONV",
+         /*3*/ "ACL,BACKUP,CONNECT2,DELTASUM2,DEL2,EXIT,FILTER2,FLIST2,FUZZY,GENR,OWN,RECV,SEND,TIME",
+         /*4*/ "CMD2,DELTASUM3,DEL3,EXIT2,FLIST3,ICONV2,OWN2,PROTO,TIME2",
+         /*5*/ "CHDIR,DELTASUM4,FLIST4,FUZZY2,HASH,HASHLINK,HLINK",
+ };
+ #define MAX_VERBOSITY ((int)(sizeof debug_verbosity / sizeof debug_verbosity[0]) - 1)
+ static const char *info_verbosity[1+MAX_VERBOSITY] = {
+         /*0*/ NULL,
+         /*1*/ "COPY,DEL,FLIST,MISC,NAME,STATS,SYMSAFE",
+         /*2*/ "BACKUP,MISC2,MOUNT,NAME2,REMOVE,SKIP",
+ };
+ #define MAX_OUT_LEVEL 4 /* The largest N allowed for any flagN word. */
+ short info_levels[COUNT_INFO], debug_levels[COUNT_DEBUG];
+ #define DEFAULT_PRIORITY 0      /* Default/implied/--verbose set values. */
+ #define HELP_PRIORITY 1         /* The help output uses this level. */
+ #define USER_PRIORITY 2         /* User-specified via --info or --debug */
+ #define LIMIT_PRIORITY 3        /* Overriding priority when limiting values. */
+ #define W_CLI (1<<0)    /* client side */
+ #define W_SRV (1<<1)    /* server side */
+ #define W_SND (1<<2)    /* sending side */
+ #define W_REC (1<<3)    /* receiving side */
+ struct output_struct {
+         char *name;     /* The name of the info/debug flag. */
+         char *help;     /* The description of the info/debug flag. */
+         uchar namelen;  /* The length of the name string. */
+         uchar flag;     /* The flag's value, for consistency check. */
+         uchar where;    /* Bits indicating where the flag is used. */
+         uchar priority; /* See *_PRIORITY defines. */
+ };
+ #define INFO_WORD(flag, where, help) { #flag, help, sizeof #flag - 1, INFO_##flag, where, 0 }
+ static struct output_struct info_words[COUNT_INFO+1] = {
+         INFO_WORD(BACKUP, W_REC, "Mention files backed up"),
+         INFO_WORD(COPY, W_REC, "Mention files copied locally on the receiving side"),
+         INFO_WORD(DEL, W_REC, "Mention deletions on the receiving side"),
+         INFO_WORD(FLIST, W_CLI, "Mention file-list receiving/sending (levels 1-2)"),
+         INFO_WORD(MISC, W_SND|W_REC, "Mention miscellaneous information (levels 1-2)"),
+         INFO_WORD(MOUNT, W_SND|W_REC, "Mention mounts that were found or skipped"),
+         INFO_WORD(NAME, W_SND|W_REC, "Mention 1) updated file/dir names, 2) unchanged names"),
+         INFO_WORD(PROGRESS, W_CLI, "Mention 1) per-file progress or 2) total transfer progress"),
+         INFO_WORD(REMOVE, W_SND, "Mention files removed on the sending side"),
+         INFO_WORD(SKIP, W_REC, "Mention files that are skipped due to options used"),
+         INFO_WORD(STATS, W_CLI|W_SRV, "Mention statistics at end of run (levels 1-3)"),
+         INFO_WORD(SYMSAFE, W_SND|W_REC, "Mention symlinks that are unsafe"),
+         { NULL, "--info", 0, 0, 0, 0 }
+ };
+ #define DEBUG_WORD(flag, where, help) { #flag, help, sizeof #flag - 1, DEBUG_##flag, where, 0 }
+ static struct output_struct debug_words[COUNT_DEBUG+1] = {
+         DEBUG_WORD(ACL, W_SND|W_REC, "Debug extra ACL info"),
+         DEBUG_WORD(BACKUP, W_REC, "Debug backup actions (levels 1-2)"),
+         DEBUG_WORD(BIND, W_CLI, "Debug socket bind actions"),
+         DEBUG_WORD(CHDIR, W_CLI|W_SRV, "Debug when the current directory changes"),
+         DEBUG_WORD(CONNECT, W_CLI, "Debug connection events (levels 1-2)"),
+         DEBUG_WORD(CMD, W_CLI, "Debug commands+options that are issued (levels 1-2)"),
+         DEBUG_WORD(DB, W_SND|W_REC, "Debug DB operations (levels 1-5)"),
+         DEBUG_WORD(DEL, W_REC, "Debug delete actions (levels 1-3)"),
+         DEBUG_WORD(DELTASUM, W_SND|W_REC, "Debug delta-transfer checksumming (levels 1-4)"),
+         DEBUG_WORD(DUP, W_REC, "Debug weeding of duplicate names"),
+         DEBUG_WORD(EXIT, W_CLI|W_SRV, "Debug exit events (levels 1-3)"),
+         DEBUG_WORD(FILTER, W_SND|W_REC, "Debug filter actions (levels 1-2)"),
+         DEBUG_WORD(FLIST, W_SND|W_REC, "Debug file-list operations (levels 1-4)"),
+         DEBUG_WORD(FUZZY, W_REC, "Debug fuzzy scoring (levels 1-2)"),
+         DEBUG_WORD(GENR, W_REC, "Debug generator functions"),
+         DEBUG_WORD(HASH, W_SND|W_REC, "Debug hashtable code"),
+         DEBUG_WORD(HASHLINK, W_REC, "Debug hashlink code (levels 1-2)"),
+         DEBUG_WORD(HLINK, W_SND|W_REC, "Debug hard-link actions (levels 1-3)"),
+         DEBUG_WORD(ICONV, W_CLI|W_SRV, "Debug iconv character conversions (levels 1-2)"),
+         DEBUG_WORD(IO, W_CLI|W_SRV, "Debug I/O routines (levels 1-4)"),
+         DEBUG_WORD(NSTR, W_CLI|W_SRV, "Debug negotiation strings"),
+         DEBUG_WORD(OWN, W_REC, "Debug ownership changes in users & groups (levels 1-2)"),
+         DEBUG_WORD(PROTO, W_CLI|W_SRV, "Debug protocol information"),
+         DEBUG_WORD(RECV, W_REC, "Debug receiver functions"),
+         DEBUG_WORD(SEND, W_SND, "Debug sender functions"),
+         DEBUG_WORD(TIME, W_REC, "Debug setting of modified times (levels 1-2)"),
+         { NULL, "--debug", 0, 0, 0, 0 }
+ };
+ static int verbose = 0;
+ static int do_stats = 0;
+ static int do_progress = 0;
  static int daemon_opt;   /* sets am_daemon after option error-reporting */
  static int omit_dir_times = 0;
+ static int omit_link_times = 0;
  static int F_option_cnt = 0;
  static int modify_window_set;
  static int itemize_changes = 0;
- Line 202  static int refused_delete, refused_archive_part, refus
+ Line 350  static int refused_delete, refused_archive_part, refus
  static int refused_partial, refused_progress, refused_delete_before;
  static int refused_delete_during;
  static int refused_inplace, refused_no_iconv;
-static char *max_size_arg, *min_size_arg;
+static BOOL usermap_via_chown, groupmap_via_chown;
+static char *outbuf_mode;
+static char *bwlimit_arg, *max_size_arg, *min_size_arg;
  static char tmp_partialdir[] = ".~tmp~";
  /** Local address to bind.  As a character string because it's
- Line 210  static char tmp_partialdir[] = ".~tmp~";
+ Line 360  static char tmp_partialdir[] = ".~tmp~";
   * address, or a hostname. **/
  char *bind_address;
+ static void output_item_help(struct output_struct *words);
-static void print_rsync_version(enum logcode f)
+/* This constructs a string that represents all the options set for either
+ * the --info or --debug setting, skipping any implied options (by -v, etc.).
+ * This is used both when conveying the user's options to the server, and
+ * when the help output wants to tell the user what options are implied. */
+static char *make_output_option(struct output_struct *words, short *levels, uchar where)
  {
-        char *subprotocol = "";
+        char *str = words == info_words ? "--info=" : "--debug=";
-        char const *got_socketpair = "no ";
+        int j, counts[MAX_OUT_LEVEL+1], pos, skipped = 0, len = 0, max = 0, lev = 0;
-        char const *have_inplace = "no ";
+        int word_count = words == info_words ? COUNT_INFO : COUNT_DEBUG;
-        char const *hardlinks = "no ";
+        char *buf;
-        char const *symtimes = "no ";
-        char const *acls = "no ";
-        char const *xattrs = "no ";
-        char const *links = "no ";
-        char const *iconv = "no ";
-        char const *ipv6 = "no ";
-        STRUCT_STAT *dumstat;
-#if SUBPROTOCOL_VERSION != 0
+        memset(counts, 0, sizeof counts);
-        if (asprintf(&subprotocol, ".PR%d", SUBPROTOCOL_VERSION) < 0)
-                out_of_memory("print_rsync_version");
-#endif
-#ifdef HAVE_SOCKETPAIR
-        got_socketpair = "";
-#endif
-#ifdef HAVE_FTRUNCATE
-        have_inplace = "";
-#endif
-#ifdef SUPPORT_HARD_LINKS
-        hardlinks = "";
-#endif
-#ifdef SUPPORT_ACLS
-        acls = "";
-#endif
-#ifdef SUPPORT_XATTRS
-        xattrs = "";
-#endif
-#ifdef SUPPORT_LINKS
-        links = "";
-#endif
-#ifdef INET6
-        ipv6 = "";
-#endif
-#ifdef ICONV_OPTION
-        iconv = "";
-#endif
-#ifdef CAN_SET_SYMLINK_TIMES
-        symtimes = "";
-#endif
-        rprintf(f, "%s  version %s  protocol version %d%s\n",
+        for (j = 0; words[j].name; j++) {
-                RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION, subprotocol);
+                if (words[j].flag != j) {
-        rprintf(f, "Copyright (C) 1996-2011 by Andrew Tridgell, Wayne Davison, and others.\n");
+                        rprintf(FERROR, "rsync: internal error on %s%s: %d != %d\n",
-        rprintf(f, "Web site: http://rsync.samba.org/\n");
+                                words == info_words ? "INFO_" : "DEBUG_",
-        rprintf(f, "Capabilities:\n");
+                                words[j].name, words[j].flag, j);
-        rprintf(f, "    %d-bit files, %d-bit inums, %d-bit timestamps, %d-bit long ints,\n",
+                        exit_cleanup(RERR_UNSUPPORTED);
-                (int)(sizeof (OFF_T) * 8),
+                }
-                (int)(sizeof dumstat->st_ino * 8), /* Don't check ino_t! */
+                if (!(words[j].where & where))
-                (int)(sizeof (time_t) * 8),
+                        continue;
-                (int)(sizeof (int64) * 8));
+                if (words[j].priority == DEFAULT_PRIORITY) {
-        rprintf(f, "    %ssocketpairs, %shardlinks, %ssymlinks, %sIPv6, batchfiles, %sinplace,\n",
+                        /* Implied items don't need to be mentioned. */
-                got_socketpair, hardlinks, links, ipv6, have_inplace);
+                        skipped++;
-        rprintf(f, "    %sappend, %sACLs, %sxattrs, %siconv, %ssymtimes\n",
+                        continue;
-                have_inplace, acls, xattrs, iconv, symtimes);
+                }
+                len += len ? 1 : strlen(str);
+                len += strlen(words[j].name);
+                len += levels[j] == 1 ? 0 : 1;
-#ifdef MAINTAINER_MODE
+                if (words[j].priority == HELP_PRIORITY)
-        rprintf(f, "Panic Action: \"%s\"\n", get_panic_action());
+                        continue; /* no abbreviating for help */
-#endif
-#if SIZEOF_INT64 < 8
+                assert(levels[j] <= MAX_OUT_LEVEL);
-        rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
+                if (++counts[levels[j]] > max) {
-#endif
+                        /* Determine which level has the most items. */
-        if (sizeof (int64) != SIZEOF_INT64) {
+                        lev = levels[j];
-                rprintf(f,
+                        max = counts[lev];
-                        "WARNING: size mismatch in SIZEOF_INT64 define (%d != %d)\n",
+                }
-                        (int) SIZEOF_INT64, (int) sizeof (int64));
          }
-        rprintf(f,"\n");
+        /* Sanity check the COUNT_* define against the length of the table. */
-        rprintf(f,"rsync comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n");
+        if (j != word_count) {
-        rprintf(f,"are welcome to redistribute it under certain conditions.  See the GNU\n");
+                rprintf(FERROR, "rsync: internal error: %s is wrong! (%d != %d)\n",
-        rprintf(f,"General Public Licence for details.\n");
+                        words == info_words ? "COUNT_INFO" : "COUNT_DEBUG",
+                        j, word_count);
+                exit_cleanup(RERR_UNSUPPORTED);
+        }
+        if (!len)
+                return NULL;
+        len++;
+        buf = new_array(char, len);
+        pos = 0;
+        if (skipped || max < 5)
+                lev = -1;
+        else {
+                if (lev == 0)
+                        pos += snprintf(buf, len, "%sNONE", str);
+                else if (lev == 1)
+                        pos += snprintf(buf, len, "%sALL", str);
+                else
+                        pos += snprintf(buf, len, "%sALL%d", str, lev);
+        for (j = 0; words[j].name && pos < len; j++) {
+                if (words[j].priority == DEFAULT_PRIORITY || levels[j] == lev || !(words[j].where & where))
+                        continue;
+                if (pos)
+                        buf[pos++] = ',';
+                else
+                        pos += strlcpy(buf+pos, str, len-pos);
+                if (pos < len)
+                        pos += strlcpy(buf+pos, words[j].name, len-pos);
+                /* Level 1 is implied by the name alone. */
+                if (levels[j] != 1 && pos < len)
+                        buf[pos++] = '0' + levels[j];
+        }
+        buf[pos] = '\0';
+        return buf;
  }
+ static void parse_output_words(struct output_struct *words, short *levels, const char *str, uchar priority)
+ {
+         const char *s;
+         int j, len, lev;
-void usage(enum logcode F)
+        for ( ; str; str = s) {
+                if ((s = strchr(str, ',')) != NULL)
+                        len = s++ - str;
+                else
+                        len = strlen(str);
+                if (!len)
+                        continue;
+                if (!isDigit(str)) {
+                        while (len && isDigit(str+len-1))
+                                len--;
+                }
+                lev = isDigit(str+len) ? atoi(str+len) : 1;
+                if (lev > MAX_OUT_LEVEL)
+                        lev = MAX_OUT_LEVEL;
+                if (len == 4 && strncasecmp(str, "help", 4) == 0) {
+                        output_item_help(words);
+                        exit_cleanup(0);
+                }
+                if (len == 4 && strncasecmp(str, "none", 4) == 0)
+                        len = lev = 0;
+                else if (len == 3 && strncasecmp(str, "all", 3) == 0)
+                        len = 0;
+                for (j = 0; words[j].name; j++) {
+                        if (!len
+                         || (len == words[j].namelen && strncasecmp(str, words[j].name, len) == 0)) {
+                                if (priority >= words[j].priority) {
+                                        words[j].priority = priority;
+                                        levels[j] = lev;
+                                }
+                                if (len)
+                                        break;
+                        }
+                }
+                if (len && !words[j].name && !am_server) {
+                        rprintf(FERROR, "Unknown %s item: \"%.*s\"\n",
+                                words[j].help, len, str);
+                        exit_cleanup(RERR_SYNTAX);
+                }
+        }
+}
+/* Tell the user what all the info or debug flags mean. */
+static void output_item_help(struct output_struct *words)
  {
-  print_rsync_version(F);
+        short *levels = words == info_words ? info_levels : debug_levels;
+        const char **verbosity = words == info_words ? info_verbosity : debug_verbosity;
+        char buf[128], *opt, *fmt = "%-10s %s\n";
+        int j;
-  rprintf(F,"\n");
+        reset_output_levels();
-  rprintf(F,"rsync is a file transfer program capable of efficient remote update\n");
-  rprintf(F,"via a fast differencing algorithm.\n");
-  rprintf(F,"\n");
+        rprintf(FINFO, "Use OPT or OPT1 for level 1 output, OPT2 for level 2, etc.; OPT0 silences.\n");
         rprintf(FINFO, "\n");
-  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST\n");
+        for (j = 0; words[j].name; j++)
-  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST\n");
+                rprintf(FINFO, fmt, words[j].name, words[j].help);
-  rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST\n");
+        rprintf(FINFO, "\n");
-  rprintf(F,"  or   rsync [OPTION]... [USER@]HOST:SRC [DEST]\n");
-  rprintf(F,"  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]\n");
-  rprintf(F,"  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]\n");
-  rprintf(F,"The ':' usages connect via remote shell, while '::' & 'rsync://' usages connect\n");
-  rprintf(F,"to an rsync daemon, and require SRC or DEST to start with a module name.\n");
-  rprintf(F,"\n");
-  rprintf(F,"Options\n");
-  rprintf(F," -v, --verbose               increase verbosity\n");
-  rprintf(F," -q, --quiet                 suppress non-error messages\n");
-  rprintf(F,"     --no-motd               suppress daemon-mode MOTD (see manpage caveat)\n");
-  rprintf(F," -c, --checksum              skip based on checksum, not mod-time & size\n");
-  rprintf(F," -a, --archive               archive mode; equals -rlptgoD (no -H,-A,-X)\n");
-  rprintf(F,"     --no-OPTION             turn off an implied OPTION (e.g. --no-D)\n");
-  rprintf(F," -r, --recursive             recurse into directories\n");
-  rprintf(F," -R, --relative              use relative path names\n");
-  rprintf(F,"     --no-implied-dirs       don't send implied dirs with --relative\n");
-  rprintf(F," -b, --backup                make backups (see --suffix & --backup-dir)\n");
-  rprintf(F,"     --backup-dir=DIR        make backups into hierarchy based in DIR\n");
-  rprintf(F,"     --suffix=SUFFIX         set backup suffix (default %s w/o --backup-dir)\n",BACKUP_SUFFIX);
-  rprintf(F," -u, --update                skip files that are newer on the receiver\n");
-  rprintf(F,"     --inplace               update destination files in-place (SEE MAN PAGE)\n");
-  rprintf(F,"     --append                append data onto shorter files\n");
-  rprintf(F,"     --append-verify         like --append, but with old data in file checksum\n");
-  rprintf(F," -d, --dirs                  transfer directories without recursing\n");
-  rprintf(F," -l, --links                 copy symlinks as symlinks\n");
-  rprintf(F," -L, --copy-links            transform symlink into referent file/dir\n");
-  rprintf(F,"     --copy-unsafe-links     only \"unsafe\" symlinks are transformed\n");
-  rprintf(F,"     --safe-links            ignore symlinks that point outside the source tree\n");
-  rprintf(F," -k, --copy-dirlinks         transform symlink to a dir into referent dir\n");
-  rprintf(F," -K, --keep-dirlinks         treat symlinked dir on receiver as dir\n");
-  rprintf(F," -H, --hard-links            preserve hard links\n");
-  rprintf(F," -p, --perms                 preserve permissions\n");
-  rprintf(F," -E, --executability         preserve the file's executability\n");
-  rprintf(F,"     --chmod=CHMOD           affect file and/or directory permissions\n");
-#ifdef SUPPORT_ACLS
-  rprintf(F," -A, --acls                  preserve ACLs (implies --perms)\n");
-#endif
-#ifdef SUPPORT_XATTRS
-  rprintf(F," -X, --xattrs                preserve extended attributes\n");
-#endif
-  rprintf(F," -o, --owner                 preserve owner (super-user only)\n");
-  rprintf(F," -g, --group                 preserve group\n");
-  rprintf(F,"     --devices               preserve device files (super-user only)\n");
-  rprintf(F,"     --specials              preserve special files\n");
-  rprintf(F," -D                          same as --devices --specials\n");
-  rprintf(F," -t, --times                 preserve modification times\n");
-  rprintf(F," -O, --omit-dir-times        omit directories from --times\n");
-  rprintf(F,"     --super                 receiver attempts super-user activities\n");
-#ifdef SUPPORT_XATTRS
-  rprintf(F,"     --fake-super            store/recover privileged attrs using xattrs\n");
-#endif
-  rprintf(F," -S, --sparse                handle sparse files efficiently\n");
-  rprintf(F," -n, --dry-run               perform a trial run with no changes made\n");
-  rprintf(F," -W, --whole-file            copy files whole (without delta-xfer algorithm)\n");
-  rprintf(F," -x, --one-file-system       don't cross filesystem boundaries\n");
-  rprintf(F," -B, --block-size=SIZE       force a fixed checksum block-size\n");
-  rprintf(F," -e, --rsh=COMMAND           specify the remote shell to use\n");
-  rprintf(F,"     --rsync-path=PROGRAM    specify the rsync to run on the remote machine\n");
-  rprintf(F,"     --existing              skip creating new files on receiver\n");
-  rprintf(F,"     --ignore-existing       skip updating files that already exist on receiver\n");
-  rprintf(F,"     --remove-source-files   sender removes synchronized files (non-dirs)\n");
-  rprintf(F,"     --del                   an alias for --delete-during\n");
-  rprintf(F,"     --delete                delete extraneous files from destination dirs\n");
-  rprintf(F,"     --delete-before         receiver deletes before transfer, not during\n");
-  rprintf(F,"     --delete-during         receiver deletes during the transfer\n");
-  rprintf(F,"     --delete-delay          find deletions during, delete after\n");
-  rprintf(F,"     --delete-after          receiver deletes after transfer, not during\n");
-  rprintf(F,"     --delete-excluded       also delete excluded files from destination dirs\n");
-  rprintf(F,"     --ignore-errors         delete even if there are I/O errors\n");
-  rprintf(F,"     --force                 force deletion of directories even if not empty\n");
-  rprintf(F,"     --max-delete=NUM        don't delete more than NUM files\n");
-  rprintf(F,"     --max-size=SIZE         don't transfer any file larger than SIZE\n");
-  rprintf(F,"     --min-size=SIZE         don't transfer any file smaller than SIZE\n");
-  rprintf(F,"     --partial               keep partially transferred files\n");
-  rprintf(F,"     --partial-dir=DIR       put a partially transferred file into DIR\n");
-  rprintf(F,"     --delay-updates         put all updated files into place at transfer's end\n");
-  rprintf(F," -m, --prune-empty-dirs      prune empty directory chains from the file-list\n");
-  rprintf(F,"     --numeric-ids           don't map uid/gid values by user/group name\n");
-  rprintf(F,"     --timeout=SECONDS       set I/O timeout in seconds\n");
-  rprintf(F,"     --contimeout=SECONDS    set daemon connection timeout in seconds\n");
-  rprintf(F," -I, --ignore-times          don't skip files that match in size and mod-time\n");
-  rprintf(F,"     --size-only             skip files that match in size\n");
-  rprintf(F,"     --modify-window=NUM     compare mod-times with reduced accuracy\n");
-  rprintf(F," -T, --temp-dir=DIR          create temporary files in directory DIR\n");
-  rprintf(F," -y, --fuzzy                 find similar file for basis if no dest file\n");
-  rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
-  rprintf(F,"     --copy-dest=DIR         ... and include copies of unchanged files\n");
-  rprintf(F,"     --link-dest=DIR         hardlink to files in DIR when unchanged\n");
-  rprintf(F," -z, --compress              compress file data during the transfer\n");
-  rprintf(F,"     --compress-level=NUM    explicitly set compression level\n");
-  rprintf(F,"     --skip-compress=LIST    skip compressing files with a suffix in LIST\n");
-  rprintf(F," -C, --cvs-exclude           auto-ignore files the same way CVS does\n");
-  rprintf(F," -f, --filter=RULE           add a file-filtering RULE\n");
-  rprintf(F," -F                          same as --filter='dir-merge /.rsync-filter'\n");
-  rprintf(F,"                             repeated: --filter='- .rsync-filter'\n");
-  rprintf(F,"     --exclude=PATTERN       exclude files matching PATTERN\n");
-  rprintf(F,"     --exclude-from=FILE     read exclude patterns from FILE\n");
-  rprintf(F,"     --include=PATTERN       don't exclude files matching PATTERN\n");
-  rprintf(F,"     --include-from=FILE     read include patterns from FILE\n");
-  rprintf(F,"     --files-from=FILE       read list of source-file names from FILE\n");
-  rprintf(F," -0, --from0                 all *-from/filter files are delimited by 0s\n");
-  rprintf(F," -s, --protect-args          no space-splitting; only wildcard special-chars\n");
-  rprintf(F,"     --address=ADDRESS       bind address for outgoing socket to daemon\n");
-  rprintf(F,"     --port=PORT             specify double-colon alternate port number\n");
-  rprintf(F,"     --sockopts=OPTIONS      specify custom TCP options\n");
-  rprintf(F,"     --blocking-io           use blocking I/O for the remote shell\n");
-  rprintf(F,"     --stats                 give some file-transfer stats\n");
-  rprintf(F," -8, --8-bit-output          leave high-bit chars unescaped in output\n");
-  rprintf(F," -h, --human-readable        output numbers in a human-readable format\n");
-  rprintf(F,"     --progress              show progress during transfer\n");
-  rprintf(F," -P                          same as --partial --progress\n");
-  rprintf(F," -i, --itemize-changes       output a change-summary for all updates\n");
-  rprintf(F,"     --out-format=FORMAT     output updates using the specified FORMAT\n");
-  rprintf(F,"     --log-file=FILE         log what we're doing to the specified FILE\n");
-  rprintf(F,"     --log-file-format=FMT   log updates using the specified FMT\n");
-  rprintf(F,"     --password-file=FILE    read daemon-access password from FILE\n");
-  rprintf(F,"     --list-only             list the files instead of copying them\n");
-  rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
-  rprintf(F,"     --write-batch=FILE      write a batched update to FILE\n");
-  rprintf(F,"     --only-write-batch=FILE like --write-batch but w/o updating destination\n");
-  rprintf(F,"     --read-batch=FILE       read a batched update from FILE\n");
-  rprintf(F,"     --protocol=NUM          force an older protocol version to be used\n");
-#ifdef ICONV_OPTION
-  rprintf(F,"     --iconv=CONVERT_SPEC    request charset conversion of filenames\n");
-#endif
-  rprintf(F," -4, --ipv4                  prefer IPv4\n");
-  rprintf(F," -6, --ipv6                  prefer IPv6\n");
-  rprintf(F,"     --version               print version number\n");
-  rprintf(F,"(-h) --help                  show this help (-h is --help only if used alone)\n");
-  rprintf(F,"\n");
+        snprintf(buf, sizeof buf, "Set all %s options (e.g. all%d)",
-  rprintf(F,"Use \"rsync --daemon --help\" to see the daemon-mode command-line options.\n");
+                 words[j].help, MAX_OUT_LEVEL);
-  rprintf(F,"Please see the rsync(1) and rsyncd.conf(5) man pages for full documentation.\n");
+        rprintf(FINFO, fmt, "ALL", buf);
-  rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
+        snprintf(buf, sizeof buf, "Silence all %s options (same as all0)",
+                 words[j].help);
+        rprintf(FINFO, fmt, "NONE", buf);
+        rprintf(FINFO, fmt, "HELP", "Output this help message");
+        rprintf(FINFO, "\n");
+        rprintf(FINFO, "Options added for each increase in verbose level:\n");
+        for (j = 1; j <= MAX_VERBOSITY; j++) {
+                parse_output_words(words, levels, verbosity[j], HELP_PRIORITY);
+                opt = make_output_option(words, levels, W_CLI|W_SRV|W_SND|W_REC);
+                if (opt) {
+                        rprintf(FINFO, "%d) %s\n", j, strchr(opt, '=')+1);
+                        free(opt);
+                }
+                reset_output_levels();
+        }
  }
-enum {OPT_VERSION = 1000, OPT_DAEMON, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
+/* The --verbose option now sets info+debug flags. */
+static void set_output_verbosity(int level, uchar priority)
+{
+        int j;
+        if (level > MAX_VERBOSITY)
+                level = MAX_VERBOSITY;
+        for (j = 1; j <= level; j++) {
+                parse_output_words(info_words, info_levels, info_verbosity[j], priority);
+                parse_output_words(debug_words, debug_levels, debug_verbosity[j], priority);
+        }
+}
+/* Limit the info+debug flag levels given a verbose-option level limit. */
+void limit_output_verbosity(int level)
+{
+        short info_limits[COUNT_INFO], debug_limits[COUNT_DEBUG];
+        int j;
+        if (level > MAX_VERBOSITY)
+                return;
+        memset(info_limits, 0, sizeof info_limits);
+        memset(debug_limits, 0, sizeof debug_limits);
+        /* Compute the level limits in the above arrays. */
+        for (j = 1; j <= level; j++) {
+                parse_output_words(info_words, info_limits, info_verbosity[j], LIMIT_PRIORITY);
+                parse_output_words(debug_words, debug_limits, debug_verbosity[j], LIMIT_PRIORITY);
+        }
+        for (j = 0; j < COUNT_INFO; j++) {
+                if (info_levels[j] > info_limits[j])
+                        info_levels[j] = info_limits[j];
+        }
+        for (j = 0; j < COUNT_DEBUG; j++) {
+                if (debug_levels[j] > debug_limits[j])
+                        debug_levels[j] = debug_limits[j];
+        }
+}
+void reset_output_levels(void)
+{
+        int j;
+        memset(info_levels, 0, sizeof info_levels);
+        memset(debug_levels, 0, sizeof debug_levels);
+        for (j = 0; j < COUNT_INFO; j++)
+                info_words[j].priority = DEFAULT_PRIORITY;
+        for (j = 0; j < COUNT_DEBUG; j++)
+                debug_words[j].priority = DEFAULT_PRIORITY;
+}
+void negate_output_levels(void)
+{
+        int j;
+        for (j = 0; j < COUNT_INFO; j++)
+                info_levels[j] *= -1;
+        for (j = 0; j < COUNT_DEBUG; j++)
+                debug_levels[j] *= -1;
+enum {OPT_SERVER = 1000, OPT_DAEMON, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
        OPT_FILTER, OPT_COMPARE_DEST, OPT_COPY_DEST, OPT_LINK_DEST, OPT_HELP,
        OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW, OPT_MIN_SIZE, OPT_CHMOD,
        OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_ONLY_WRITE_BATCH, OPT_MAX_SIZE,
-      OPT_NO_D, OPT_APPEND, OPT_NO_ICONV,
+      OPT_NO_D, OPT_APPEND, OPT_NO_ICONV, OPT_INFO, OPT_DEBUG, OPT_BLOCK_SIZE,
-      OPT_SERVER, OPT_REFUSED_BASE = 9000};
+      OPT_USERMAP, OPT_GROUPMAP, OPT_CHOWN, OPT_BWLIMIT, OPT_STDERR, OPT_SUMFILES,
+      OPT_OLD_COMPRESS, OPT_NEW_COMPRESS, OPT_NO_COMPRESS,
+      OPT_STOP_AFTER, OPT_STOP_AT,
+      OPT_REFUSED_BASE = 9000};
  static struct poptOption long_options[] = {
    /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
    {"help",             0,  POPT_ARG_NONE,   0, OPT_HELP, 0, 0 },
-  {"version",          0,  POPT_ARG_NONE,   0, OPT_VERSION, 0, 0},
+  {"version",         'V', POPT_ARG_NONE,   0, 'V', 0, 0},
    {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
    {"no-verbose",       0,  POPT_ARG_VAL,    &verbose, 0, 0, 0 },
    {"no-v",             0,  POPT_ARG_VAL,    &verbose, 0, 0, 0 },
+   {"info",             0,  POPT_ARG_STRING, 0, OPT_INFO, 0, 0 },
+   {"debug",            0,  POPT_ARG_STRING, 0, OPT_DEBUG, 0, 0 },
+   {"stderr",           0,  POPT_ARG_STRING, 0, OPT_STDERR, 0, 0 },
+   {"msgs2stderr",      0,  POPT_ARG_VAL,    &msgs2stderr, 1, 0, 0 },
+   {"no-msgs2stderr",   0,  POPT_ARG_VAL,    &msgs2stderr, 0, 0, 0 },
    {"quiet",           'q', POPT_ARG_NONE,   0, 'q', 0, 0 },
    {"motd",             0,  POPT_ARG_VAL,    &output_motd, 1, 0, 0 },
    {"no-motd",          0,  POPT_ARG_VAL,    &output_motd, 0, 0, 0 },
- Line 479  static struct poptOption long_options[] = {
+ Line 648  static struct poptOption long_options[] = {
    {"perms",           'p', POPT_ARG_VAL,    &preserve_perms, 1, 0, 0 },
    {"no-perms",         0,  POPT_ARG_VAL,    &preserve_perms, 0, 0, 0 },
    {"no-p",             0,  POPT_ARG_VAL,    &preserve_perms, 0, 0, 0 },
+   {"fileflags",        0,  POPT_ARG_VAL,    &preserve_fileflags, 1, 0, 0 },
+   {"no-fileflags",     0,  POPT_ARG_VAL,    &preserve_fileflags, 0, 0, 0 },
    {"executability",   'E', POPT_ARG_NONE,   &preserve_executability, 0, 0, 0 },
    {"acls",            'A', POPT_ARG_NONE,   0, 'A', 0, 0 },
    {"no-acls",          0,  POPT_ARG_VAL,    &preserve_acls, 0, 0, 0 },
- Line 489  static struct poptOption long_options[] = {
+ Line 660  static struct poptOption long_options[] = {
    {"times",           't', POPT_ARG_VAL,    &preserve_times, 1, 0, 0 },
    {"no-times",         0,  POPT_ARG_VAL,    &preserve_times, 0, 0, 0 },
    {"no-t",             0,  POPT_ARG_VAL,    &preserve_times, 0, 0, 0 },
+   {"atimes",          'U', POPT_ARG_NONE,   0, 'U', 0, 0 },
+   {"no-atimes",        0,  POPT_ARG_VAL,    &preserve_atimes, 0, 0, 0 },
+   {"no-U",             0,  POPT_ARG_VAL,    &preserve_atimes, 0, 0, 0 },
+   {"open-noatime",     0,  POPT_ARG_VAL,    &open_noatime, 1, 0, 0 },
+   {"no-open-noatime",  0,  POPT_ARG_VAL,    &open_noatime, 0, 0, 0 },
+   {"crtimes",         'N', POPT_ARG_VAL,    &preserve_crtimes, 1, 0, 0 },
+   {"no-crtimes",       0,  POPT_ARG_VAL,    &preserve_crtimes, 0, 0, 0 },
+   {"no-N",             0,  POPT_ARG_VAL,    &preserve_crtimes, 0, 0, 0 },
    {"omit-dir-times",  'O', POPT_ARG_VAL,    &omit_dir_times, 1, 0, 0 },
    {"no-omit-dir-times",0,  POPT_ARG_VAL,    &omit_dir_times, 0, 0, 0 },
    {"no-O",             0,  POPT_ARG_VAL,    &omit_dir_times, 0, 0, 0 },
-  {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
+  {"omit-link-times", 'J', POPT_ARG_VAL,    &omit_link_times, 1, 0, 0 },
+  {"no-omit-link-times",0, POPT_ARG_VAL,    &omit_link_times, 0, 0, 0 },
+  {"no-J",             0,  POPT_ARG_VAL,    &omit_link_times, 0, 0, 0 },
+  {"omit-dir-changes", 0,  POPT_ARG_NONE,   &omit_dir_changes, 0, 0, 0 },
+  {"modify-window",   '@', POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
    {"super",            0,  POPT_ARG_VAL,    &am_root, 2, 0, 0 },
    {"no-super",         0,  POPT_ARG_VAL,    &am_root, 0, 0, 0 },
    {"fake-super",       0,  POPT_ARG_VAL,    &am_root, -1, 0, 0 },
- Line 506  static struct poptOption long_options[] = {
+ Line 689  static struct poptOption long_options[] = {
    {"no-D",             0,  POPT_ARG_NONE,   0, OPT_NO_D, 0, 0 },
    {"devices",          0,  POPT_ARG_VAL,    &preserve_devices, 1, 0, 0 },
    {"no-devices",       0,  POPT_ARG_VAL,    &preserve_devices, 0, 0, 0 },
+   {"copy-devices",     0,  POPT_ARG_NONE,   &copy_devices, 0, 0, 0 },
+   {"write-devices",    0,  POPT_ARG_VAL,    &write_devices, 1, 0, 0 },
+   {"no-write-devices", 0,  POPT_ARG_VAL,    &write_devices, 0, 0, 0 },
    {"specials",         0,  POPT_ARG_VAL,    &preserve_specials, 1, 0, 0 },
    {"no-specials",      0,  POPT_ARG_VAL,    &preserve_specials, 0, 0, 0 },
    {"links",           'l', POPT_ARG_VAL,    &preserve_links, 1, 0, 0 },
- Line 514  static struct poptOption long_options[] = {
+ Line 700  static struct poptOption long_options[] = {
    {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
    {"copy-unsafe-links",0,  POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
    {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
+   {"munge-links",      0,  POPT_ARG_VAL,    &munge_symlinks, 1, 0, 0 },
+   {"no-munge-links",   0,  POPT_ARG_VAL,    &munge_symlinks, 0, 0, 0 },
    {"copy-dirlinks",   'k', POPT_ARG_NONE,   &copy_dirlinks, 0, 0, 0 },
    {"keep-dirlinks",   'K', POPT_ARG_NONE,   &keep_dirlinks, 0, 0, 0 },
    {"hard-links",      'H', POPT_ARG_NONE,   0, 'H', 0, 0 },
- Line 529  static struct poptOption long_options[] = {
+ Line 717  static struct poptOption long_options[] = {
    {"chmod",            0,  POPT_ARG_STRING, 0, OPT_CHMOD, 0, 0 },
    {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
    {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
+   {"date-only",        0,  POPT_ARG_NONE,   &date_only, 0, 0, 0 },
    {"one-file-system", 'x', POPT_ARG_NONE,   0, 'x', 0, 0 },
    {"no-one-file-system",0, POPT_ARG_VAL,    &one_file_system, 0, 0, 0 },
    {"no-x",             0,  POPT_ARG_VAL,    &one_file_system, 0, 0, 0 },
    {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
+   {"downdate",        'w', POPT_ARG_NONE,   &downdate_only, 0, 0, 0 },
    {"existing",         0,  POPT_ARG_NONE,   &ignore_non_existing, 0, 0, 0 },
    {"ignore-non-existing",0,POPT_ARG_NONE,   &ignore_non_existing, 0, 0, 0 },
    {"ignore-existing",  0,  POPT_ARG_NONE,   &ignore_existing, 0, 0, 0 },
    {"max-size",         0,  POPT_ARG_STRING, &max_size_arg, OPT_MAX_SIZE, 0, 0 },
    {"min-size",         0,  POPT_ARG_STRING, &min_size_arg, OPT_MIN_SIZE, 0, 0 },
+   {"max-alloc",        0,  POPT_ARG_STRING, &max_alloc_arg, 0, 0, 0 },
    {"sparse",          'S', POPT_ARG_VAL,    &sparse_files, 1, 0, 0 },
    {"no-sparse",        0,  POPT_ARG_VAL,    &sparse_files, 0, 0, 0 },
    {"no-S",             0,  POPT_ARG_VAL,    &sparse_files, 0, 0, 0 },
+   {"sparse-block",     0,  POPT_ARG_LONG,   &sparse_files_block_size, 0, 0, 0 },
+   {"preallocate",      0,  POPT_ARG_NONE,   &preallocate_files, 0, 0, 0},
    {"inplace",          0,  POPT_ARG_VAL,    &inplace, 1, 0, 0 },
    {"no-inplace",       0,  POPT_ARG_VAL,    &inplace, 0, 0, 0 },
    {"append",           0,  POPT_ARG_NONE,   0, OPT_APPEND, 0, 0 },
- Line 553  static struct poptOption long_options[] = {
+ Line 746  static struct poptOption long_options[] = {
    {"delete-delay",     0,  POPT_ARG_VAL,    &delete_during, 2, 0, 0 },
    {"delete-after",     0,  POPT_ARG_NONE,   &delete_after, 0, 0, 0 },
    {"delete-excluded",  0,  POPT_ARG_NONE,   &delete_excluded, 0, 0, 0 },
+   {"delete-missing-args",0,POPT_BIT_SET,    &missing_args, 2, 0, 0 },
+   {"ignore-missing-args",0,POPT_BIT_SET,    &missing_args, 1, 0, 0 },
    {"remove-sent-files",0,  POPT_ARG_VAL,    &remove_source_files, 2, 0, 0 }, /* deprecated */
    {"remove-source-files",0,POPT_ARG_VAL,    &remove_source_files, 1, 0, 0 },
    {"force",            0,  POPT_ARG_VAL,    &force_delete, 1, 0, 0 },
    {"no-force",         0,  POPT_ARG_VAL,    &force_delete, 0, 0, 0 },
+   {"force-delete",     0,  POPT_ARG_VAL,    &force_delete, 1, 0, 0 },
+   {"no-force-delete",  0,  POPT_ARG_VAL,    &force_delete, 0, 0, 0 },
+   {"force-change",     0,  POPT_ARG_VAL,    &force_change, ALL_IMMUTABLE, 0, 0 },
+   {"no-force-change",  0,  POPT_ARG_VAL,    &force_change, 0, 0, 0 },
+   {"force-uchange",    0,  POPT_ARG_VAL,    &force_change, USR_IMMUTABLE, 0, 0 },
+   {"force-schange",    0,  POPT_ARG_VAL,    &force_change, SYS_IMMUTABLE, 0, 0 },
+   {"hfs-compression",  0,  POPT_ARG_VAL,    &preserve_hfs_compression, 1, 0, 0 },
+   {"no-hfs-compression",0, POPT_ARG_VAL,    &preserve_hfs_compression, 0, 0, 0 },
+   {"protect-decmpfs",  0,  POPT_ARG_VAL,    &preserve_hfs_compression, 2, 0, 0 },
+   {"no-protect-decmpfs",0, POPT_ARG_VAL,    &preserve_hfs_compression, 0, 0, 0 },
    {"ignore-errors",    0,  POPT_ARG_VAL,    &ignore_errors, 1, 0, 0 },
    {"no-ignore-errors", 0,  POPT_ARG_VAL,    &ignore_errors, 0, 0, 0 },
    {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
- Line 573  static struct poptOption long_options[] = {
+ Line 778  static struct poptOption long_options[] = {
    {"checksum",        'c', POPT_ARG_VAL,    &always_checksum, 1, 0, 0 },
    {"no-checksum",      0,  POPT_ARG_VAL,    &always_checksum, 0, 0, 0 },
    {"no-c",             0,  POPT_ARG_VAL,    &always_checksum, 0, 0, 0 },
-  {"block-size",      'B', POPT_ARG_LONG,   &block_size, 0, 0, 0 },
+  {"checksum-choice",  0,  POPT_ARG_STRING, &checksum_choice, 0, 0, 0 },
+  {"cc",               0,  POPT_ARG_STRING, &checksum_choice, 0, 0, 0 },
+  {"sumfiles",         0,  POPT_ARG_STRING, 0, OPT_SUMFILES, 0, 0 },
+  {"block-size",      'B', POPT_ARG_STRING, 0, OPT_BLOCK_SIZE, 0, 0 },
    {"compare-dest",     0,  POPT_ARG_STRING, 0, OPT_COMPARE_DEST, 0, 0 },
    {"copy-dest",        0,  POPT_ARG_STRING, 0, OPT_COPY_DEST, 0, 0 },
    {"link-dest",        0,  POPT_ARG_STRING, 0, OPT_LINK_DEST, 0, 0 },
-  {"fuzzy",           'y', POPT_ARG_VAL,    &fuzzy_basis, 1, 0, 0 },
+  {"clone-dest",       0,  POPT_ARG_STRING, 0, OPT_CLONE_DEST, 0, 0 },
+  {"fuzzy",           'y', POPT_ARG_NONE,   0, 'y', 0, 0 },
    {"no-fuzzy",         0,  POPT_ARG_VAL,    &fuzzy_basis, 0, 0, 0 },
    {"no-y",             0,  POPT_ARG_VAL,    &fuzzy_basis, 0, 0, 0 },
    {"compress",        'z', POPT_ARG_NONE,   0, 'z', 0, 0 },
-  {"no-compress",      0,  POPT_ARG_VAL,    &do_compression, 0, 0, 0 },
+  {"old-compress",     0,  POPT_ARG_NONE,   0, OPT_OLD_COMPRESS, 0, 0 },
-  {"no-z",             0,  POPT_ARG_VAL,    &do_compression, 0, 0, 0 },
+  {"new-compress",     0,  POPT_ARG_NONE,   0, OPT_NEW_COMPRESS, 0, 0 },
+  {"no-compress",      0,  POPT_ARG_NONE,   0, OPT_NO_COMPRESS, 0, 0 },
+  {"no-z",             0,  POPT_ARG_NONE,   0, OPT_NO_COMPRESS, 0, 0 },
+  {"compress-choice",  0,  POPT_ARG_STRING, &compress_choice, 0, 0, 0 },
+  {"zc",               0,  POPT_ARG_STRING, &compress_choice, 0, 0, 0 },
    {"skip-compress",    0,  POPT_ARG_STRING, &skip_compress, 0, 0, 0 },
-  {"compress-level",   0,  POPT_ARG_INT,    &def_compress_level, 'z', 0, 0 },
+  {"compress-level",   0,  POPT_ARG_INT,    &do_compression_level, 0, 0, 0 },
+  {"zl",               0,  POPT_ARG_INT,    &do_compression_level, 0, 0, 0 },
    {0,                 'P', POPT_ARG_NONE,   0, 'P', 0, 0 },
    {"progress",         0,  POPT_ARG_VAL,    &do_progress, 1, 0, 0 },
    {"no-progress",      0,  POPT_ARG_VAL,    &do_progress, 0, 0, 0 },
- Line 593  static struct poptOption long_options[] = {
+ Line 807  static struct poptOption long_options[] = {
    {"partial-dir",      0,  POPT_ARG_STRING, &partial_dir, 0, 0, 0 },
    {"delay-updates",    0,  POPT_ARG_VAL,    &delay_updates, 1, 0, 0 },
    {"no-delay-updates", 0,  POPT_ARG_VAL,    &delay_updates, 0, 0, 0 },
+   {"direct-io",       'n', POPT_ARG_VAL,    &direct_io, 1, 0, 0 },
+   {"no-direct-io",     0,  POPT_ARG_VAL,    &direct_io, 0, 0, 0 },
    {"prune-empty-dirs",'m', POPT_ARG_VAL,    &prune_empty_dirs, 1, 0, 0 },
    {"no-prune-empty-dirs",0,POPT_ARG_VAL,    &prune_empty_dirs, 0, 0, 0 },
    {"no-m",             0,  POPT_ARG_VAL,    &prune_empty_dirs, 0, 0, 0 },
- Line 603  static struct poptOption long_options[] = {
+ Line 819  static struct poptOption long_options[] = {
    {"itemize-changes", 'i', POPT_ARG_NONE,   0, 'i', 0, 0 },
    {"no-itemize-changes",0, POPT_ARG_VAL,    &itemize_changes, 0, 0, 0 },
    {"no-i",             0,  POPT_ARG_VAL,    &itemize_changes, 0, 0, 0 },
-  {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
+  {"slow-down",        0,  POPT_ARG_LONG,   &sleep_asec, 0, 0, 0 },
+  {"bwlimit",          0,  POPT_ARG_STRING, &bwlimit_arg, OPT_BWLIMIT, 0, 0 },
    {"no-bwlimit",       0,  POPT_ARG_VAL,    &bwlimit, 0, 0, 0 },
-  {"backup",          'b', POPT_ARG_VAL,    &make_backups, 1, 0, 0 },
+  {"backup",          'b', POPT_ARG_VAL,    &make_backups, 2, 0, 0 },
+  {"backup-deleted",   0,  POPT_ARG_VAL,    &make_backups, 1, 0, 0 },
    {"no-backup",        0,  POPT_ARG_VAL,    &make_backups, 0, 0, 0 },
    {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
+   {"backup-dir-dels",  0,  POPT_ARG_STRING, &backup_dir_dels, 0, 0, 0 },
    {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
+   {"suffix-dels",      0,  POPT_ARG_STRING, &backup_suffix_dels, 0, 0, 0 },
    {"list-only",        0,  POPT_ARG_VAL,    &list_only, 2, 0, 0 },
    {"read-batch",       0,  POPT_ARG_STRING, &batch_name, OPT_READ_BATCH, 0, 0 },
    {"write-batch",      0,  POPT_ARG_STRING, &batch_name, OPT_WRITE_BATCH, 0, 0 },
    {"only-write-batch", 0,  POPT_ARG_STRING, &batch_name, OPT_ONLY_WRITE_BATCH, 0, 0 },
+   {"ignore-case",      0,  POPT_ARG_VAL,    &ignore_case, 1, 0, 0 },
+   {"no-ignore-case",   0,  POPT_ARG_VAL,    &ignore_case, 0, 0, 0 },
    {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
    {"from0",           '0', POPT_ARG_VAL,    &eol_nulls, 1, 0, 0},
    {"no-from0",         0,  POPT_ARG_VAL,    &eol_nulls, 0, 0, 0},
- Line 621  static struct poptOption long_options[] = {
+ Line 843  static struct poptOption long_options[] = {
    {"no-s",             0,  POPT_ARG_VAL,    &protect_args, 0, 0, 0},
    {"numeric-ids",      0,  POPT_ARG_VAL,    &numeric_ids, 1, 0, 0 },
    {"no-numeric-ids",   0,  POPT_ARG_VAL,    &numeric_ids, 0, 0, 0 },
+   {"usermap",          0,  POPT_ARG_STRING, 0, OPT_USERMAP, 0, 0 },
+   {"groupmap",         0,  POPT_ARG_STRING, 0, OPT_GROUPMAP, 0, 0 },
+   {"chown",            0,  POPT_ARG_STRING, 0, OPT_CHOWN, 0, 0 },
    {"timeout",          0,  POPT_ARG_INT,    &io_timeout, 0, 0, 0 },
    {"no-timeout",       0,  POPT_ARG_VAL,    &io_timeout, 0, 0, 0 },
    {"contimeout",       0,  POPT_ARG_INT,    &connect_timeout, 0, 0, 0 },
    {"no-contimeout",    0,  POPT_ARG_VAL,    &connect_timeout, 0, 0, 0 },
+   {"fsync",            0,  POPT_ARG_NONE,   &do_fsync, 0, 0, 0 },
+   {"stop-after",       0,  POPT_ARG_STRING, 0, OPT_STOP_AFTER, 0, 0 },
+   {"time-limit",       0,  POPT_ARG_STRING, 0, OPT_STOP_AFTER, 0, 0 }, /* earlier stop-after name */
+   {"stop-at",          0,  POPT_ARG_STRING, 0, OPT_STOP_AT, 0, 0 },
    {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
    {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path, 0, 0, 0 },
    {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
- #ifdef ICONV_OPTION
    {"iconv",            0,  POPT_ARG_STRING, &iconv_opt, 0, 0, 0 },
    {"no-iconv",         0,  POPT_ARG_NONE,   0, OPT_NO_ICONV, 0, 0 },
-#endif
+  {"tr",               0,  POPT_ARG_STRING, &tr_opt, 0, 0, 0 },
    {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
    {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
    {"8-bit-output",    '8', POPT_ARG_VAL,    &allow_8bit_chars, 1, 0, 0 },
    {"no-8-bit-output",  0,  POPT_ARG_VAL,    &allow_8bit_chars, 0, 0, 0 },
    {"no-8",             0,  POPT_ARG_VAL,    &allow_8bit_chars, 0, 0, 0 },
+   {"mkpath",           0,  POPT_ARG_VAL,    &mkpath_dest_arg, 1, 0, 0 },
+   {"no-mkpath",        0,  POPT_ARG_VAL,    &mkpath_dest_arg, 0, 0, 0 },
    {"qsort",            0,  POPT_ARG_NONE,   &use_qsort, 0, 0, 0 },
+   {"copy-as",          0,  POPT_ARG_STRING, &copy_as, 0, 0, 0 },
    {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
    {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
    {"sockopts",         0,  POPT_ARG_STRING, &sockopts, 0, 0, 0 },
    {"password-file",    0,  POPT_ARG_STRING, &password_file, 0, 0, 0 },
+   {"early-input",      0,  POPT_ARG_STRING, &early_input_file, 0, 0, 0 },
    {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
    {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
+   {"source-filter",    0,  POPT_ARG_STRING, &source_filter, 0, 0, 0 },
+   {"dest-filter",      0,  POPT_ARG_STRING, &dest_filter, 0, 0, 0 },
+   {"outbuf",           0,  POPT_ARG_STRING, &outbuf_mode, 0, 0, 0 },
+   {"remote-option",   'M', POPT_ARG_STRING, 0, 'M', 0, 0 },
    {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
+   {"congestion-alg",   0,  POPT_ARG_STRING, &congestion_alg, 0, 0, 0 },
+   {"diffserv",         0,  POPT_ARG_INT,    &diffserv, 0, 0, 0 },
    {"checksum-seed",    0,  POPT_ARG_INT,    &checksum_seed, 0, 0, 0 },
    {"server",           0,  POPT_ARG_NONE,   0, OPT_SERVER, 0, 0 },
    {"sender",           0,  POPT_ARG_NONE,   0, OPT_SENDER, 0, 0 },
    /* All the following options switch us into daemon-mode option-parsing. */
    {"config",           0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
    {"daemon",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
+   {"dparam",           0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
    {"detach",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
    {"no-detach",        0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
+   /* All the following options switch us into DB-admin option-parsing. */
+   {"db-help",          0,  POPT_ARG_NONE,   0, OPT_DBONLY, 0, 0 },
+   {"db-only",          0,  POPT_ARG_STRING, 0, OPT_DBONLY, 0, 0 },
    {0,0,0,0, 0, 0, 0}
  };
- static void daemon_usage(enum logcode F)
- {
-   print_rsync_version(F);
-   rprintf(F,"\n");
-   rprintf(F,"Usage: rsync --daemon [OPTION]...\n");
-   rprintf(F,"     --address=ADDRESS       bind to the specified address\n");
-   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
-   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");
-   rprintf(F,"     --no-detach             do not detach from the parent\n");
-   rprintf(F,"     --port=PORT             listen on alternate port number\n");
-   rprintf(F,"     --log-file=FILE         override the \"log file\" setting\n");
-   rprintf(F,"     --log-file-format=FMT   override the \"log format\" setting\n");
-   rprintf(F,"     --sockopts=OPTIONS      specify custom TCP options\n");
-   rprintf(F," -v, --verbose               increase verbosity\n");
-   rprintf(F," -4, --ipv4                  prefer IPv4\n");
-   rprintf(F," -6, --ipv6                  prefer IPv6\n");
-   rprintf(F,"     --help                  show this help screen\n");
-   rprintf(F,"\n");
-   rprintf(F,"If you were not trying to invoke rsync as a daemon, avoid using any of the\n");
-   rprintf(F,"daemon-specific rsync options.  See also the rsyncd.conf(5) man page.\n");
- }
  static struct poptOption long_daemon_options[] = {
    /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
    {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
    {"bwlimit",          0,  POPT_ARG_INT,    &daemon_bwlimit, 0, 0, 0 },
    {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
    {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
+   {"dparam",          'M', POPT_ARG_STRING, 0, 'M', 0, 0 },
    {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
    {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
    {"detach",           0,  POPT_ARG_VAL,    &no_detach, 0, 0, 0 },
- Line 704  static struct poptOption long_daemon_options[] = {
+ Line 923  static struct poptOption long_daemon_options[] = {
    {0,0,0,0, 0, 0, 0}
  };
+ static struct poptOption long_dbonly_options[] = {
+   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
+   {"check",           'c', POPT_ARG_NONE,   &db_check, 0, 0, 0},
+   {"clean",            0,  POPT_ARG_NONE,   &db_clean, 0, 0, 0},
+   {"db",               0,  POPT_ARG_STRING, &db_config, 0, 0, 0 },
+   {"db-only",          0,  POPT_ARG_STRING, &db_config, 0, 0, 0 },
+   {"db-lax",           0,  POPT_ARG_VAL,    &db_lax, 1, 0, 0 },
+   {"no-db-lax",        0,  POPT_ARG_VAL,    &db_lax, 0, 0, 0 },
+   {"info",             0,  POPT_ARG_STRING, 0, OPT_INFO, 0, 0 },
+   {"debug",            0,  POPT_ARG_STRING, 0, OPT_DEBUG, 0, 0 },
+   {"update",          'u', POPT_ARG_VAL,    &db_update, 1, 0, 0 },
+   {"no-update",       'N', POPT_ARG_VAL,    &db_update, 0, 0, 0 },
+   {"no-u",             0,  POPT_ARG_VAL,    &db_update, 0, 0, 0 },
+   {"output",          'o', POPT_ARG_STRING, 0, 'o', 0, 0 },
+   {"recursive",       'r', POPT_ARG_VAL,    &recurse, 1, 0, 0 },
+   {"no-recursive",     0,  POPT_ARG_VAL,    &recurse, 0, 0, 0 },
+   {"no-r",             0,  POPT_ARG_VAL,    &recurse, 0, 0, 0 },
+   {"sums",            's', POPT_ARG_STRING, 0, 's', 0, 0 },
+   {"init",             0,  POPT_ARG_NONE,   &db_init, 0, 0, 0 },
+   {"mounts",           0,  POPT_ARG_NONE,   &db_mounts, 0, 0, 0 },
+   {"quiet",           'q', POPT_ARG_NONE,   &quiet, 0, 0, 0 },
+   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
+   {"db-help",          0,  POPT_ARG_NONE,   0, 'h', 0, 0 },
+   {0,0,0,0, 0, 0, 0}
+ };
  static char err_buf[200];
- Line 722  void option_error(void)
+ Line 966  void option_error(void)
          }
          rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
+         io_flush(MSG_FLUSH);
          msleep(20);
  }
+ static void parse_one_refuse_match(int negated, const char *ref, const struct poptOption *list_end)
+ {
+         struct poptOption *op;
+         char shortName[2];
+         int is_wild = strpbrk(ref, "*?[") != NULL;
+         int found_match = 0;
+         shortName[1] = '\0';
+         if (strcmp("a", ref) == 0 || strcmp("archive", ref) == 0) {
+                 ref = "[ardlptgoD]";
+                 is_wild = 1;
+         }
+         for (op = long_options; op != list_end; op++) {
+                 *shortName = op->shortName;
+                 if ((op->longName && wildmatch(ref, op->longName))
+                  || (*shortName && wildmatch(ref, shortName))) {
+                         if (op->descrip[1] == '*')
+                                 op->descrip = negated ? "a*" : "r*";
+                         else if (!is_wild)
+                                 op->descrip = negated ? "a=" : "r=";
+                         found_match = 1;
+                         if (!is_wild)
+                                 break;
+                 }
+         }
+         if (!found_match)
+                 rprintf(FLOG, "No match for refuse-options string \"%s\"\n", ref);
+ }
  /**
   * Tweak the option table to disable all options that the rsyncd.conf
   * file has told us to refuse.
   **/
-static void set_refuse_options(char *bp)
+static void set_refuse_options(void)
  {
-        struct poptOption *op;
+        struct poptOption *op, *list_end = NULL;
-        char *cp, shortname[2];
+        char *cp, *ref = lp_refuse_options(module_id);
-        int is_wild, found_match;
+        int negated;
-        shortname[1] = '\0';
+        if (!ref)
+                ref = "";
-        while (1) {
+        if (!am_daemon)
-                while (*bp == ' ') bp++;
+                ref = "";
-                if (!*bp)
+        /* We abuse the descrip field in poptOption to make it easy to flag which options
+         * are refused (since we don't use it otherwise).  Start by marking all options
+         * as "a"ccepted with a few options also marked as non-wild. */
+        for (op = long_options; ; op++) {
+                const char *longName = op->longName ? op->longName : "";
+                if (!op->longName && !op->shortName) {
+                        list_end = op;
                          break;
-                 if ((cp = strchr(bp, ' ')) != NULL)
-                         *cp= '\0';
-                 is_wild = strpbrk(bp, "*?[") != NULL;
-                 found_match = 0;
-                 for (op = long_options; ; op++) {
-                         *shortname = op->shortName;
-                         if (!op->longName && !*shortname)
-                                 break;
-                         if ((op->longName && wildmatch(bp, op->longName))
-                             || (*shortname && wildmatch(bp, shortname))) {
-                                 if (op->argInfo == POPT_ARG_VAL)
-                                         op->argInfo = POPT_ARG_NONE;
-                                 op->val = (op - long_options) + OPT_REFUSED_BASE;
-                                 found_match = 1;
-                                 /* These flags are set to let us easily check
-                                  * an implied option later in the code. */
-                                 switch (*shortname) {
-                                 case 'r': case 'd': case 'l': case 'p':
-                                 case 't': case 'g': case 'o': case 'D':
-                                         refused_archive_part = op->val;
-                                         break;
-                                 case 'z':
-                                         refused_compress = op->val;
-                                         break;
-                                 case '\0':
-                                         if (wildmatch("delete", op->longName))
-                                                 refused_delete = op->val;
-                                         else if (wildmatch("delete-before", op->longName))
-                                                 refused_delete_before = op->val;
-                                         else if (wildmatch("delete-during", op->longName))
-                                                 refused_delete_during = op->val;
-                                         else if (wildmatch("partial", op->longName))
-                                                 refused_partial = op->val;
-                                         else if (wildmatch("progress", op->longName))
-                                                 refused_progress = op->val;
-                                         else if (wildmatch("inplace", op->longName))
-                                                 refused_inplace = op->val;
-                                         else if (wildmatch("no-iconv", op->longName))
-                                                 refused_no_iconv = op->val;
-                                         break;
-                                 }
-                                 if (!is_wild)
-                                         break;
-                         }
                  }
-                if (!found_match) {
+                if (!am_daemon
-                        rprintf(FLOG, "No match for refuse-options string \"%s\"\n",
+                 || op->shortName == 'e' /* Required for compatibility flags */
-                                bp);
+                 || op->shortName == '0' /* --from0 just modifies --files-from, so refuse that instead (or not) */
-                }
+                 || op->shortName == 's' /* --protect-args is always OK */
+                 || op->shortName == 'n' /* --dry-run is always OK */
+                 || strcmp("iconv", longName) == 0
+                 || strcmp("no-iconv", longName) == 0
+                 || strcmp("checksum-seed", longName) == 0
+                 || strcmp("copy-devices", longName) == 0 /* disable wild-match (it gets refused below) */
+                 || strcmp("write-devices", longName) == 0 /* disable wild-match (it gets refused below) */
+                 || strcmp("log-format", longName) == 0 /* aka out-format (NOT log-file-format) */
+                 || strcmp("sender", longName) == 0
+                 || strcmp("server", longName) == 0)
+                        op->descrip = "a="; /* exact-match only */
+                else
+                        op->descrip = "a*"; /* wild-card-able */
+        }
+        assert(list_end != NULL);
+        if (am_daemon) { /* Refused by default, but can be accepted via a negated exact match. */
+                parse_one_refuse_match(0, "copy-devices", list_end);
+                parse_one_refuse_match(0, "write-devices", list_end);
+        }
+        while (1) {
+                while (*ref == ' ') ref++;
+                if (!*ref)
+                        break;
+                if ((cp = strchr(ref, ' ')) != NULL)
+                        *cp = '\0';
+                negated = *ref == '!';
+                if (negated && ref[1])
+                        ref++;
+                parse_one_refuse_match(negated, ref, list_end);
                  if (!cp)
                          break;
                  *cp = ' ';
-                bp = cp + 1;
+                ref = cp + 1;
          }
+         if (*lp_link_by_hash_dir(module_id))
+                 parse_one_refuse_match(0, "link-by-hash", list_end);
+         if (am_daemon) {
+ #ifdef ICONV_OPTION
+                 if (!*lp_charset(module_id))
+                         parse_one_refuse_match(0, "iconv", list_end);
+ #endif
+                 parse_one_refuse_match(0, "log-file*", list_end);
+                 parse_one_refuse_match(0, "db", list_end);
+                 parse_one_refuse_match(0, "db-lax", list_end);
+         }
+ #ifndef SUPPORT_ATIMES
+         parse_one_refuse_match(0, "atimes", list_end);
+ #endif
+ #ifndef SUPPORT_HARD_LINKS
+         parse_one_refuse_match(0, "link-dest", list_end);
+ #endif
+ #ifndef FICLONE
+         parse_one_refuse_match(0, "clone-dest", list_end);
+ #endif
+ #ifndef HAVE_MKTIME
+         parse_one_refuse_match(0, "stop-at", list_end);
+ #endif
+ #ifndef ICONV_OPTION
+         parse_one_refuse_match(0, "iconv", list_end);
+ #endif
+ #ifndef HAVE_SETVBUF
+         parse_one_refuse_match(0, "outbuf", list_end);
+ #endif
+ #ifndef SUPPORT_CRTIMES
+         parse_one_refuse_match(0, "crtimes", list_end);
+ #endif
+ #ifndef SUPPORT_FILEFLAGS
+         parse_one_refuse_match(0, "fileflags", list_end);
+ #endif
+ #ifndef SUPPORT_FORCE_CHANGE
+         parse_one_refuse_match(0, "force-change", list_end);
+         parse_one_refuse_match(0, "force-uchange", list_end);
+         parse_one_refuse_match(0, "force-schange", list_end);
+ #endif
+ #ifndef SUPPORT_HFS_COMPRESSION
+         parse_one_refuse_match(0, "hfs-compression", list_end);
+         parse_one_refuse_match(0, "protect-decmpfs", list_end);
+ #endif
+         /* Now we use the descrip values to actually mark the options for refusal. */
+         for (op = long_options; op != list_end; op++) {
+                 int refused = op->descrip[0] == 'r';
+                 op->descrip = NULL;
+                 if (!refused)
+                         continue;
+                 if (op->argInfo == POPT_ARG_VAL)
+                         op->argInfo = POPT_ARG_NONE;
+                 op->val = (op - long_options) + OPT_REFUSED_BASE;
+                 /* The following flags are set to let us easily check an implied option later in the code. */
+                 switch (op->shortName) {
+                 case 'r': case 'd': case 'l': case 'p':
+                 case 't': case 'g': case 'o': case 'D':
+                         refused_archive_part = op->val;
+                         break;
+                 case 'z':
+                         refused_compress = op->val;
+                         break;
+                 case '\0':
+                         if (strcmp("delete", op->longName) == 0)
+                                 refused_delete = op->val;
+                         else if (strcmp("delete-before", op->longName) == 0)
+                                 refused_delete_before = op->val;
+                         else if (strcmp("delete-during", op->longName) == 0)
+                                 refused_delete_during = op->val;
+                         else if (strcmp("partial", op->longName) == 0)
+                                 refused_partial = op->val;
+                         else if (strcmp("progress", op->longName) == 0)
+                                 refused_progress = op->val;
+                         else if (strcmp("inplace", op->longName) == 0)
+                                 refused_inplace = op->val;
+                         else if (strcmp("no-iconv", op->longName) == 0)
+                                 refused_no_iconv = op->val;
+                         break;
+                 }
+         }
  }
- Line 811  static int count_args(const char **argv)
+ Line 1167  static int count_args(const char **argv)
          return i;
  }
 /* If the size_arg is an invalid string or the value is < min_value, an error
-static OFF_T parse_size_arg(char **size_arg, char def_suf)
+ * is put into err_buf & the return is -1.  Note that this parser does NOT
+ * support negative numbers, so a min_value < 0 doesn't make any sense. */
+static ssize_t parse_size_arg(const char *size_arg, char def_suf, const char *opt_name,
+                              ssize_t min_value, ssize_t max_value, BOOL unlimited_0)
  {
-        int reps, mult, make_compatible = 0;
+        int reps, mult, len;
-        const char *arg;
+        const char *arg, *err = "invalid", *min_max = NULL;
-        OFF_T size = 1;
+        ssize_t limit = -1, size = 1;
-        for (arg = *size_arg; isDigit(arg); arg++) {}
+        for (arg = size_arg; isDigit(arg); arg++) {}
-        if (*arg == '.')
+        if (*arg == '.' || *arg == get_decimal_point()) /* backward compatibility: always allow '.' */
                  for (arg++; isDigit(arg); arg++) {}
          switch (*arg && *arg != '+' && *arg != '-' ? *arg++ : def_suf) {
          case 'b': case 'B':
- Line 834  static OFF_T parse_size_arg(char **size_arg, char def_
+ Line 1193  static OFF_T parse_size_arg(char **size_arg, char def_
          case 'g': case 'G':
                  reps = 3;
                  break;
+         case 't': case 'T':
+                 reps = 4;
+                 break;
+         case 'p': case 'P':
+                 reps = 5;
+                 break;
          default:
-                return -1;
+                goto failure;
          }
          if (*arg == 'b' || *arg == 'B')
-                mult = 1000, make_compatible = 1, arg++;
+                mult = 1000, arg++;
          else if (!*arg || *arg == '+' || *arg == '-')
                  mult = 1024;
          else if (strncasecmp(arg, "ib", 2) == 0)
                  mult = 1024, arg += 2;
          else
-                return -1;
+                goto failure;
          while (reps--)
                  size *= mult;
-        size *= atof(*size_arg);
+        size *= atof(size_arg);
-        if ((*arg == '+' || *arg == '-') && arg[1] == '1')
+        if ((*arg == '+' || *arg == '-') && arg[1] == '1' && arg != size_arg)
-                size += atoi(arg), make_compatible = 1, arg += 2;
+                size += atoi(arg), arg += 2;
          if (*arg)
-                return -1;
+                goto failure;
-        if (size > 0 && make_compatible) {
+        if (size < 0 || (max_value >= 0 && size > max_value)) {
-                /* We convert this manually because we may need %lld precision,
+                err = "too large";
-                 * and that's not a portable sprintf() escape. */
+                min_max = "max";
-                char buf[128], *s = buf + sizeof buf - 1;
+                limit = max_value;
-                OFF_T num = size;
+                goto failure;
-                *s = '\0';
-                while (num) {
-                        *--s = (char)(num % 10) + '0';
-                        num /= 10;
-                }
-                if (!(*size_arg = strdup(s)))
-                        out_of_memory("parse_size_arg");
          }
+         if (size < min_value && (!unlimited_0 || size != 0)) {
+                 err = "too small";
+                 min_max = "min";
+                 limit = min_value;
+                 goto failure;
+         }
          return size;
+ failure:
+         len = snprintf(err_buf, sizeof err_buf - 1, "--%s=%s is %s", opt_name, size_arg, err);
+         if (min_max && limit >= 0 && len < (int)sizeof err_buf - 10) {
+                 len += snprintf(err_buf + len, sizeof err_buf - len - 1, " (%s: %s%s)",
+                         min_max, do_big_num(limit, 3, NULL),
+                         unlimited_0 && min_max[1] == 'i' ? " or 0 for unlimited" : "");
+         }
+         err_buf[len] = '\n';
+         err_buf[len+1] = '\0';
+         return -1;
  }
+ #ifdef HAVE_MKTIME
+ /* Allow the user to specify a time in the format yyyy-mm-ddThh:mm while
+  * also allowing abbreviated data.  For instance, if the time is omitted,
+  * it defaults to midnight.  If the date is omitted, it defaults to the
+  * next possible date in the future with the specified time.  Even the
+  * year or year-month can be omitted, again defaulting to the next date
+  * in the future that matches the specified information.  A 2-digit year
+  * is also OK, as is using '/' instead of '-'. */
+ static time_t parse_time(const char *arg)
+ {
+         const char *cp;
+         time_t val, now = time(NULL);
+         struct tm t, *today = localtime(&now);
+         int in_date, old_mday, n;
+         memset(&t, 0, sizeof t);
+         t.tm_year = t.tm_mon = t.tm_mday = -1;
+         t.tm_hour = t.tm_min = t.tm_isdst = -1;
+         cp = arg;
+         if (*cp == 'T' || *cp == 't' || *cp == ':') {
+                 in_date = *cp == ':' ? 0 : -1;
+                 cp++;
+         } else
+                 in_date = 1;
+         for ( ; ; cp++) {
+                 if (!isDigit(cp))
+                         return (time_t)-1;
+                 n = 0;
+                 do {
+                         n = n * 10 + *cp++ - '0';
+                 } while (isDigit(cp));
+                 if (*cp == ':')
+                         in_date = 0;
+                 if (in_date > 0) {
+                         if (t.tm_year != -1)
+                                 return (time_t)-1;
+                         t.tm_year = t.tm_mon;
+                         t.tm_mon = t.tm_mday;
+                         t.tm_mday = n;
+                         if (!*cp)
+                                 break;
+                         if (*cp == 'T' || *cp == 't') {
+                                 if (!cp[1])
+                                         break;
+                                 in_date = -1;
+                         } else if (*cp != '-' && *cp != '/')
+                                 return (time_t)-1;
+                         continue;
+                 }
+                 if (t.tm_hour != -1)
+                         return (time_t)-1;
+                 t.tm_hour = t.tm_min;
+                 t.tm_min = n;
+                 if (!*cp) {
+                         if (in_date < 0)
+                                 return (time_t)-1;
+                         break;
+                 }
+                 if (*cp != ':')
+                         return (time_t)-1;
+                 in_date = 0;
+         }
+         in_date = 0;
+         if (t.tm_year < 0) {
+                 t.tm_year = today->tm_year;
+                 in_date = 1;
+         } else if (t.tm_year < 100) {
+                 while (t.tm_year < today->tm_year)
+                         t.tm_year += 100;
+         } else
+                 t.tm_year -= 1900;
+         if (t.tm_mon < 0) {
+                 t.tm_mon = today->tm_mon;
+                 in_date = 2;
+         } else
+                 t.tm_mon--;
+         if (t.tm_mday < 0) {
+                 t.tm_mday = today->tm_mday;
+                 in_date = 3;
+         }
+         n = 0;
+         if (t.tm_min < 0) {
+                 t.tm_hour = t.tm_min = 0;
+         } else if (t.tm_hour < 0) {
+                 if (in_date != 3)
+                         return (time_t)-1;
+                 in_date = 0;
+                 t.tm_hour = today->tm_hour;
+                 n = 60*60;
+         }
+         /* Note that mktime() might change a too-large tm_mday into the start of
+          * the following month which we need to undo in the following code! */
+         old_mday = t.tm_mday;
+         if (t.tm_hour > 23 || t.tm_min > 59
+             || t.tm_mon < 0 || t.tm_mon >= 12
+             || t.tm_mday < 1 || t.tm_mday > 31
+             || (val = mktime(&t)) == (time_t)-1)
+                 return (time_t)-1;
+         while (in_date && (val <= now || t.tm_mday < old_mday)) {
+                 switch (in_date) {
+                 case 3:
+                         old_mday = ++t.tm_mday;
+                         break;
+                 case 2:
+                         if (t.tm_mday < old_mday)
+                                 t.tm_mday = old_mday; /* The month already got bumped forward */
+                         else if (++t.tm_mon == 12) {
+                                 t.tm_mon = 0;
+                                 t.tm_year++;
+                         }
+                         break;
+                 case 1:
+                         if (t.tm_mday < old_mday) {
+                                 /* mon==1 mday==29 got bumped to mon==2 */
+                                 if (t.tm_mon != 2 || old_mday != 29)
+                                         return (time_t)-1;
+                                 t.tm_mon = 1;
+                                 t.tm_mday = 29;
+                         }
+                         t.tm_year++;
+                         break;
+                 }
+                 if ((val = mktime(&t)) == (time_t)-1) {
+                         /* This code shouldn't be needed, as mktime() should auto-round to the next month. */
+                         if (in_date != 3 || t.tm_mday <= 28)
+                                 return (time_t)-1;
+                         t.tm_mday = old_mday = 1;
+                         in_date = 2;
+                 }
+         }
+         if (n) {
+                 while (val <= now)
+                         val += n;
+         }
+         return val;
+ }
+ #endif
  static void create_refuse_error(int which)
  {
+         const char *msg;
+         if (am_daemon)
+                 msg = "The server is configured to refuse";
+         else if (am_server)
+                 msg = "The server does not support";
+         else
+                 msg = "This rsync does not support";
          /* The "which" value is the index + OPT_REFUSED_BASE. */
          struct poptOption *op = &long_options[which - OPT_REFUSED_BASE];
-        int n = snprintf(err_buf, sizeof err_buf,
+        int n = snprintf(err_buf, sizeof err_buf, "%s --%s\n", msg, op->longName) - 1;
-                         "The server is configured to refuse --%s\n",
+        if (op->shortName)
-                         op->longName) - 1;
+                snprintf(err_buf + n, sizeof err_buf - n, " (-%c)\n", op->shortName);
         if (op->shortName) {
                 snprintf(err_buf + n, sizeof err_buf - n,
-                         " (-%c)\n", op->shortName);
+static NORETURN void parse_dbonly_args(int argc, const char **argv)
+{
+        poptContext pc = poptGetContext(RSYNC_NAME, argc, argv, long_dbonly_options, 0);
+        const char *arg;
+        int opt;
+        recurse = 1;
+        am_dbadmin = 1;
+        while ((opt = poptGetNextOpt(pc)) != -1) {
+                const char *cp;
+                switch (opt) {
+                case 'o':
+                        for (cp = poptGetOptArg(pc); *cp; cp++) {
+                                switch (toLower(cp)) {
+                                case 'n':
+                                        db_output_name = 1;
+                                        break;
+                                case 's':
+                                case 'c':
+                                        db_output_sum = db_output_name = 1;
+                                        break;
+                                case 'i':
+                                        db_output_info = db_output_name = 1;
+                                        break;
+                                case 'u':
+                                        db_output_unchanged = db_output_name = 1;
+                                        break;
+                                case 'd':
+                                        db_output_dirs = 1;
+                                        break;
+                                }
+                        }
+                        saw_db_output_opt = 1;
+                        break;
+                case 's':
+                        for (cp = poptGetOptArg(pc); *cp; cp++) {
+                                switch (*cp) {
+                                case '4':
+                                        db_do_md4 = 1;
+                                        break;
+                                case '5':
+                                        db_do_md5 = 1;
+                                        break;
+                                }
+                        }
+                        saw_db_sum_opt = 1;
+                        break;
+                case 'h':
+                        dbonly_usage(FINFO);
+                        exit_cleanup(0);
+                case OPT_INFO:
+                        arg = poptGetOptArg(pc);
+                        parse_output_words(info_words, info_levels, arg, USER_PRIORITY);
+                        break;
+                case OPT_DEBUG:
+                        arg = poptGetOptArg(pc);
+                        parse_output_words(debug_words, debug_levels, arg, USER_PRIORITY);
+                        break;
+                default:
+                        rprintf(FERROR,
+                                "rsyncdb: %s: %s\n",
+                                poptBadOption(pc, POPT_BADOPTION_NOALIAS),
+                                poptStrerror(opt));
+                        goto dbonly_usage;
+                }
          }
+         if (!db_config) {
+                 rprintf(FERROR, "You must specify the --db=FILE option.\n");
+           dbonly_usage:
+                 rprintf(FERROR,
+                         "(Type \"rsyncdb --help\" for assistance.)\n");
+                 exit_cleanup(RERR_SYNTAX);
+         }
+         if (!saw_db_output_opt && !quiet) {
+                 db_output_dirs = db_output_name = 1;
+                 if (db_check)
+                         db_output_info = 1;
+         }
+         if (!quiet)
+                 db_output_msgs = 1;
+         if (!saw_db_sum_opt)
+                 db_do_md5 = 1;
+         am_starting_up = 0;
+         run_dbonly(poptGetArgs(pc));
+         exit(42); /* NOT REACHED */
  }
+ /* This is used to make sure that --daemon & --server cannot be aliased to
+  * something else. These options have always disabled popt aliases for the
+  * parsing of a daemon or server command-line, but we have to make sure that
+  * these options cannot vanish so that the alias disabling can take effect. */
+ static void popt_unalias(poptContext con, const char *opt)
+ {
+         struct poptAlias unalias;
+         memset(&unalias, 0, sizeof unalias);
+         unalias.longName = opt + 2; /* point past the leading "--" */
+         unalias.argc = 1;
+         unalias.argv = new_array0(const char*, 2);
+         unalias.argv[0] = strdup(opt);
+         poptAddAlias(con, unalias, 0);
+ }
+ char *alt_dest_opt(int type)
+ {
+         if (!type)
+                 type = alt_dest_type;
+         switch (type) {
+         case COMPARE_DEST:
+                 return "--compare-dest";
+         case COPY_DEST:
+                 return "--copy-dest";
+         case LINK_DEST:
+                 return "--link-dest";
+         case CLONE_DEST:
+                 return "--clone-dest";
+         default:
+                 NOISY_DEATH("Unknown alt_dest_opt type");
+         }
+ }
  /**
   * Process command line arguments.  Called on both local and remote.
   *
- Line 894  static void create_refuse_error(int which)
+ Line 1546  static void create_refuse_error(int which)
  int parse_arguments(int *argc_p, const char ***argv_p)
  {
          static poptContext pc;
-         char *ref = lp_refuse_options(module_id);
          const char *arg, **argv = *argv_p;
          int argc = *argc_p;
-        int opt;
+        int opt, want_dest_type;
+        int orig_protect_args = protect_args;
-        if (ref && *ref)
+        if (argc == 0) {
-                set_refuse_options(ref);
+                strlcpy(err_buf, "argc is zero!\n", sizeof err_buf);
-        if (am_daemon) {
+                return 0;
-                set_refuse_options("log-file*");
-#ifdef ICONV_OPTION
-                if (!*lp_charset(module_id))
-                        set_refuse_options("iconv");
-#endif
          }
+         arg = *argv + strlen(*argv);
+         if (arg - *argv > 2 && strcmp(arg-2, "db") == 0) {
+                 parse_dbonly_args(argc, argv);
+                 /* NOT REACHED */
+         }
+         set_refuse_options();
  #ifdef ICONV_OPTION
-        if (!am_daemon && !protect_args && (arg = getenv("RSYNC_ICONV")) != NULL && *arg)
+        if (!am_daemon && protect_args <= 0 && (arg = getenv("RSYNC_ICONV")) != NULL && *arg)
                  iconv_opt = strdup(arg);
  #endif
- Line 921  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1576  int parse_arguments(int *argc_p, const char ***argv_p)
          if (pc)
                  poptFreeContext(pc);
          pc = poptGetContext(RSYNC_NAME, argc, argv, long_options, 0);
-        if (!am_server)
+        if (!am_server) {
                  poptReadDefaultConfig(pc, 0);
+                 popt_unalias(pc, "--daemon");
+                 popt_unalias(pc, "--server");
+         }
          while ((opt = poptGetNextOpt(pc)) != -1) {
                  /* most options are handled automatically by popt;
                   * only special cases are returned and listed here. */
                  switch (opt) {
-                case OPT_VERSION:
+                case 'V':
-                        print_rsync_version(FINFO);
+                        version_opt_cnt++;
-                        exit_cleanup(0);
+                        break;
                  case OPT_SERVER:
                          if (!am_server) {
                                  /* Disable popt aliases on the server side and
                                   * then start parsing the options again. */
                                  poptFreeContext(pc);
-                                pc = poptGetContext(RSYNC_NAME, argc, argv,
+                                pc = poptGetContext(RSYNC_NAME, argc, argv, long_options, 0);
-                                                    long_options, 0);
                                  am_server = 1;
                          }
  #ifdef ICONV_OPTION
- Line 965  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1622  int parse_arguments(int *argc_p, const char ***argv_p)
  #ifdef ICONV_OPTION
                          iconv_opt = NULL;
  #endif
+                         protect_args = 0;
                          poptFreeContext(pc);
-                        pc = poptGetContext(RSYNC_NAME, argc, argv,
+                        pc = poptGetContext(RSYNC_NAME, argc, argv, long_daemon_options, 0);
-                                            long_daemon_options, 0);
                          while ((opt = poptGetNextOpt(pc)) != -1) {
+                                 char **cpp;
                                  switch (opt) {
                                  case 'h':
                                          daemon_usage(FINFO);
                                          exit_cleanup(0);
+                                 case 'M':
+                                         arg = poptGetOptArg(pc);
+                                         if (!strchr(arg, '=')) {
+                                                 rprintf(FERROR,
+                                                         "--dparam value is missing an '=': %s\n",
+                                                         arg);
+                                                 goto daemon_error;
+                                         }
+                                         cpp = EXPAND_ITEM_LIST(&dparam_list, char *, 4);
+                                         *cpp = strdup(arg);
+                                         break;
                                  case 'v':
                                          verbose++;
                                          break;
                                  default:
                                          rprintf(FERROR,
-                                            "rsync: %s: %s (in daemon mode)\n",
+                                                "rsync: %s: %s (in daemon mode)\n",
                                                 poptBadOption(pc, POPT_BADOPTION_NOALIAS),
-                                            poptStrerror(opt));
+                                                poptStrerror(opt));
                                          goto daemon_error;
                                  }
                          }
+                         if (dparam_list.count && !set_dparams(1))
+                                 exit_cleanup(RERR_SYNTAX);
                          if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
                                  snprintf(err_buf, sizeof err_buf,
                                           "the --temp-dir path is WAY too long.\n");
- Line 996  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1669  int parse_arguments(int *argc_p, const char ***argv_p)
                          if (!daemon_opt) {
                                  rprintf(FERROR, "Daemon option(s) used without --daemon.\n");
                              daemon_error:
-                                rprintf(FERROR,
+                                rprintf(FERROR, "(Type \"rsync --daemon --help\" for assistance with daemon mode.)\n");
-                                    "(Type \"rsync --daemon --help\" for assistance with daemon mode.)\n");
                                  exit_cleanup(RERR_SYNTAX);
                          }
- Line 1008  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1680  int parse_arguments(int *argc_p, const char ***argv_p)
                          am_daemon = 1;
                          return 1;
+                 case OPT_DBONLY:
+                         protect_args = 0;
+                         poptFreeContext(pc);
+                         parse_dbonly_args(argc, argv);
+                         break; /* NOT REACHED */
                  case OPT_MODIFY_WINDOW:
                          /* The value has already been set by popt, but
                           * we need to remember that we're using a
- Line 1016  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1694  int parse_arguments(int *argc_p, const char ***argv_p)
                          break;
                  case OPT_FILTER:
-                        parse_rule(&filter_list, poptGetOptArg(pc), 0, 0);
+                        parse_filter_str(&filter_list, poptGetOptArg(pc),
+                                        rule_template(0), 0);
                          break;
                  case OPT_EXCLUDE:
-                        parse_rule(&filter_list, poptGetOptArg(pc),
+                        parse_filter_str(&filter_list, poptGetOptArg(pc),
-, XFLG_OLD_PREFIXES);
+                                        rule_template(0), XFLG_OLD_PREFIXES);
                          break;
                  case OPT_INCLUDE:
-                        parse_rule(&filter_list, poptGetOptArg(pc),
+                        parse_filter_str(&filter_list, poptGetOptArg(pc),
-                                   MATCHFLG_INCLUDE, XFLG_OLD_PREFIXES);
+                                        rule_template(FILTRULE_INCLUDE), XFLG_OLD_PREFIXES);
                          break;
                  case OPT_EXCLUDE_FROM:
- Line 1036  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1715  int parse_arguments(int *argc_p, const char ***argv_p)
                                  arg = sanitize_path(NULL, arg, NULL, 0, SP_DEFAULT);
                          if (daemon_filter_list.head) {
                                  int rej;
-                                char *dir, *cp = strdup(arg);
+                                char *cp = strdup(arg);
-                                if (!cp)
-                                        out_of_memory("parse_arguments");
                                  if (!*cp)
-                                        goto options_rejected;
+                                        rej = 1;
                                 else {
                                         char *dir = cp + (*cp == '/' ? module_dirlen : 0);
-                                rej = check_filter(&daemon_filter_list, FLOG, dir, 0) < 0;
+                                        clean_fname(dir, CFN_COLLAPSE_DOT_DOT_DIRS);
+                                        rej = check_filter(&daemon_filter_list, FLOG, dir, 0) < 0;
                                  free(cp);
                                  if (rej)
                                          goto options_rejected;
                          }
                          parse_filter_file(&filter_list, arg,
-                                opt == OPT_INCLUDE_FROM ? MATCHFLG_INCLUDE : 0,
+                                rule_template(opt == OPT_INCLUDE_FROM ? FILTRULE_INCLUDE : 0),
                                  XFLG_FATAL_ERRORS | XFLG_OLD_PREFIXES);
                          break;
- Line 1079  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1758  int parse_arguments(int *argc_p, const char ***argv_p)
                          preserve_devices = preserve_specials = 0;
                          break;
+                 case OPT_NO_DB:
+                         db_config = NULL;
+                         break;
                  case 'h':
                          human_readable++;
                          break;
- Line 1091  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1774  int parse_arguments(int *argc_p, const char ***argv_p)
                          itemize_changes++;
                          break;
+                 case 'U':
+                         if (++preserve_atimes > 1)
+                                 open_noatime = 1;
+                         break;
                  case 'v':
                          verbose++;
                          break;
+                 case 'y':
+                         fuzzy_basis++;
+                         break;
                  case 'q':
                          quiet++;
                          break;
- Line 1106  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1798  int parse_arguments(int *argc_p, const char ***argv_p)
                  case 'F':
                          switch (++F_option_cnt) {
                          case 1:
-                                parse_rule(&filter_list,": /.rsync-filter",0,0);
+                                parse_filter_str(&filter_list,": /.rsync-filter",rule_template(0),0);
                                  break;
                          case 2:
-                                parse_rule(&filter_list,"- .rsync-filter",0,0);
+                                parse_filter_str(&filter_list,"- .rsync-filter",rule_template(0),0);
                                  break;
                          }
                          break;
                  case 'P':
                          if (refused_partial || refused_progress) {
-                                create_refuse_error(refused_partial
+                                create_refuse_error(refused_partial ? refused_partial : refused_progress);
-                                    ? refused_partial : refused_progress);
                                  return 0;
                          }
                          do_progress = 1;
- Line 1125  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1816  int parse_arguments(int *argc_p, const char ***argv_p)
                          break;
                  case 'z':
-                        if (def_compress_level < Z_DEFAULT_COMPRESSION
+                        do_compression++;
-                         || def_compress_level > Z_BEST_COMPRESSION) {
+                        break;
+                case OPT_OLD_COMPRESS:
+                        compress_choice = "zlib";
+                        break;
+                case OPT_NEW_COMPRESS:
+                        compress_choice = "zlibx";
+                        break;
+                case OPT_NO_COMPRESS:
+                        do_compression = 0;
+                        compress_choice = NULL;
+                        break;
+                case 'M':
+                        arg = poptGetOptArg(pc);
+                        if (*arg != '-') {
                                  snprintf(err_buf, sizeof err_buf,
-                                        "--compress-level value is invalid: %d\n",
+                                        "Remote option must start with a dash: %s\n", arg);
-                                        def_compress_level);
                                  return 0;
                          }
-                        do_compression = def_compress_level != Z_NO_COMPRESSION;
+                        if (remote_option_cnt+2 >= remote_option_alloc) {
-                        if (do_compression && refused_compress) {
+                                remote_option_alloc += 16;
-                                create_refuse_error(refused_compress);
+                                remote_options = realloc_array(remote_options,
-                                return 0;
+                                                        const char *, remote_option_alloc);
+                                if (!remote_option_cnt)
+                                        remote_options[0] = "ARG0";
                          }
+                         remote_options[++remote_option_cnt] = arg;
+                         remote_options[remote_option_cnt+1] = NULL;
                          break;
                  case OPT_WRITE_BATCH:
- Line 1160  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1871  int parse_arguments(int *argc_p, const char ***argv_p)
  #endif
                          break;
+                 case OPT_BLOCK_SIZE: {
+                         /* We may not know the real protocol_version at this point if this is the client
+                          * option parsing, but we still want to check it so that the client can specify
+                          * a --protocol=29 option with a larger block size. */
+                         int max_blength = protocol_version < 30 ? OLD_MAX_BLOCK_SIZE : MAX_BLOCK_SIZE;
+                         ssize_t size;
+                         arg = poptGetOptArg(pc);
+                         if ((size = parse_size_arg(arg, 'b', "block-size", 0, max_blength, False)) < 0)
+                                 return 0;
+                         block_size = (int32)size;
+                         break;
+                 }
                  case OPT_MAX_SIZE:
-                        if ((max_size = parse_size_arg(&max_size_arg, 'b')) <= 0) {
+                        if ((max_size = parse_size_arg(max_size_arg, 'b', "max-size", 0, -1, False)) < 0)
-                                snprintf(err_buf, sizeof err_buf,
-                                        "--max-size value is invalid: %s\n",
-                                        max_size_arg);
                                  return 0;
-                        }
+                        max_size_arg = strdup(do_big_num(max_size, 0, NULL));
                          break;
                  case OPT_MIN_SIZE:
-                        if ((min_size = parse_size_arg(&min_size_arg, 'b')) <= 0) {
+                        if ((min_size = parse_size_arg(min_size_arg, 'b', "min-size", 0, -1, False)) < 0)
-                                snprintf(err_buf, sizeof err_buf,
-                                        "--min-size value is invalid: %s\n",
-                                        min_size_arg);
                                  return 0;
-                        }
+                        min_size_arg = strdup(do_big_num(min_size, 0, NULL));
                          break;
+                 case OPT_BWLIMIT: {
+                         ssize_t size = parse_size_arg(bwlimit_arg, 'K', "bwlimit", 512, -1, True);
+                         if (size < 0)
+                                 return 0;
+                         bwlimit_arg = strdup(do_big_num(size, 0, NULL));
+                         bwlimit = (size + 512) / 1024;
+                         break;
+                 }
                  case OPT_APPEND:
                          if (am_server)
                                  append_mode++;
- Line 1186  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1913  int parse_arguments(int *argc_p, const char ***argv_p)
                          break;
                  case OPT_LINK_DEST:
-#ifdef SUPPORT_HARD_LINKS
+                        want_dest_type = LINK_DEST;
-                        link_dest = 1;
-                        dest_option = "--link-dest";
                          goto set_dest_dir;
- #else
-                         snprintf(err_buf, sizeof err_buf,
-                                  "hard links are not supported on this %s\n",
-                                  am_server ? "server" : "client");
-                         return 0;
- #endif
+                 case OPT_CLONE_DEST:
+                         want_dest_type = CLONE_DEST;
+                         goto set_dest_dir;
                  case OPT_COPY_DEST:
-                        copy_dest = 1;
+                        want_dest_type = COPY_DEST;
-                        dest_option = "--copy-dest";
                          goto set_dest_dir;
                  case OPT_COMPARE_DEST:
-                        compare_dest = 1;
+                        want_dest_type = COMPARE_DEST;
-                        dest_option = "--compare-dest";
                  set_dest_dir:
+                         if (alt_dest_type && alt_dest_type != want_dest_type) {
+                                 snprintf(err_buf, sizeof err_buf,
+                                         "ERROR: the %s option conflicts with the %s option\n",
+                                         alt_dest_opt(want_dest_type), alt_dest_opt(0));
+                                 return 0;
+                         }
+                         alt_dest_type = want_dest_type;
                          if (basis_dir_cnt >= MAX_BASIS_DIRS) {
                                  snprintf(err_buf, sizeof err_buf,
                                          "ERROR: at most %d %s args may be specified\n",
-                                        MAX_BASIS_DIRS, dest_option);
+                                        MAX_BASIS_DIRS, alt_dest_opt(0));
                                  return 0;
                          }
                          /* We defer sanitizing this arg until we know what
- Line 1221  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 1951  int parse_arguments(int *argc_p, const char ***argv_p)
                          arg = poptGetOptArg(pc);
                          if (!parse_chmod(arg, &chmod_modes)) {
                                  snprintf(err_buf, sizeof err_buf,
-                                    "Invalid argument passed to --chmod (%s)\n",
+                                        "Invalid argument passed to --chmod (%s)\n",
+                                        arg);
+                                return 0;
+                        }
+                        break;
+                case OPT_SUMFILES:
+                        arg = poptGetOptArg(pc);
+                        if (*arg == '+') {
+                                arg++;
+                                checksum_files = CSF_UPDATE;
+                                if (*arg == '+') {
+                                        arg++;
+                                        checksum_files |= CSF_AFFECT_DRYRUN;
+                                }
+                        } else
+                                checksum_files = 0;
+                        if (strcmp(arg, "lax") == 0)
+                                checksum_files |= CSF_LAX_MODE;
+                        else if (strcmp(arg, "strict") == 0)
+                                checksum_files |= CSF_STRICT_MODE;
+                        else if (strcmp(arg, "none") == 0)
+                                checksum_files = CSF_IGNORE_FILES;
+                        else {
+                                snprintf(err_buf, sizeof err_buf,
+                                    "Invalid argument passed to --sumfiles (%s)\n",
                                      arg);
                                  return 0;
                          }
                          break;
+                 case OPT_INFO:
+                         arg = poptGetOptArg(pc);
+                         parse_output_words(info_words, info_levels, arg, USER_PRIORITY);
+                         break;
+                 case OPT_DEBUG:
+                         arg = poptGetOptArg(pc);
+                         parse_output_words(debug_words, debug_levels, arg, USER_PRIORITY);
+                         break;
+                 case OPT_USERMAP:
+                         if (usermap) {
+                                 if (usermap_via_chown) {
+                                         snprintf(err_buf, sizeof err_buf,
+                                                 "--usermap conflicts with prior --chown.\n");
+                                         return 0;
+                                 }
+                                 snprintf(err_buf, sizeof err_buf,
+                                         "You can only specify --usermap once.\n");
+                                 return 0;
+                         }
+                         usermap = (char *)poptGetOptArg(pc);
+                         usermap_via_chown = False;
+                         break;
+                 case OPT_GROUPMAP:
+                         if (groupmap) {
+                                 if (groupmap_via_chown) {
+                                         snprintf(err_buf, sizeof err_buf,
+                                                 "--groupmap conflicts with prior --chown.\n");
+                                         return 0;
+                                 }
+                                 snprintf(err_buf, sizeof err_buf,
+                                         "You can only specify --groupmap once.\n");
+                                 return 0;
+                         }
+                         groupmap = (char *)poptGetOptArg(pc);
+                         groupmap_via_chown = False;
+                         break;
+                 case OPT_CHOWN: {
+                         const char *chown = poptGetOptArg(pc);
+                         int len;
+                         if ((arg = strchr(chown, ':')) != NULL)
+                                 len = arg++ - chown;
+                         else
+                                 len = strlen(chown);
+                         if (len) {
+                                 if (usermap) {
+                                         if (!usermap_via_chown) {
+                                                 snprintf(err_buf, sizeof err_buf,
+                                                         "--chown conflicts with prior --usermap.\n");
+                                                 return 0;
+                                         }
+                                         snprintf(err_buf, sizeof err_buf,
+                                                 "You can only specify a user-affecting --chown once.\n");
+                                         return 0;
+                                 }
+                                 if (asprintf(&usermap, "*:%.*s", len, chown) < 0)
+                                         out_of_memory("parse_arguments");
+                                 usermap_via_chown = True;
+                         }
+                         if (arg && *arg) {
+                                 if (groupmap) {
+                                         if (!groupmap_via_chown) {
+                                                 snprintf(err_buf, sizeof err_buf,
+                                                         "--chown conflicts with prior --groupmap.\n");
+                                                 return 0;
+                                         }
+                                         snprintf(err_buf, sizeof err_buf,
+                                                 "You can only specify a group-affecting --chown once.\n");
+                                         return 0;
+                                 }
+                                 if (asprintf(&groupmap, "*:%s", arg) < 0)
+                                         out_of_memory("parse_arguments");
+                                 groupmap_via_chown = True;
+                         }
+                         break;
+                 }
                  case OPT_HELP:
                          usage(FINFO);
                          exit_cleanup(0);
- Line 1243  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2078  int parse_arguments(int *argc_p, const char ***argv_p)
                           * of any more restrictive ACLs, but this is safe
                           * for now */
                          snprintf(err_buf,sizeof(err_buf),
                                  "ACLs are not supported on this %s\n",
                                   am_server ? "server" : "client");
                          return 0;
  #endif
- Line 1259  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2094  int parse_arguments(int *argc_p, const char ***argv_p)
                          return 0;
  #endif
+                 case OPT_LINK_BY_HASH:
+ #ifdef HAVE_LINK
+                         arg = poptGetOptArg(pc);
+                         if (sanitize_paths)
+                                 arg = sanitize_path(NULL, arg, NULL, 0, SP_DEFAULT);
+                         link_by_hash_dir = (char *)arg;
+                         break;
+ #else
+                         snprintf(err_buf, sizeof err_buf,
+                                  "hard links are not supported on this %s\n",
+                                  am_server ? "server" : "client");
+                         return 0;
+ #endif
+                 case OPT_STOP_AFTER: {
+                         long val;
+                         arg = poptGetOptArg(pc);
+                         stop_at_utime = time(NULL);
+                         if ((val = atol(arg) * 60) <= 0 || LONG_MAX - val < stop_at_utime || (long)(time_t)val != val) {
+                                 snprintf(err_buf, sizeof err_buf, "invalid --stop-after value: %s\n", arg);
+                                 return 0;
+                         }
+                         stop_at_utime += val;
+                         break;
+                 }
+ #ifdef HAVE_MKTIME
+                 case OPT_STOP_AT:
+                         arg = poptGetOptArg(pc);
+                         if ((stop_at_utime = parse_time(arg)) == (time_t)-1) {
+                                 snprintf(err_buf, sizeof err_buf, "invalid --stop-at format: %s\n", arg);
+                                 return 0;
+                         }
+                         if (stop_at_utime <= time(NULL)) {
+                                 snprintf(err_buf, sizeof err_buf, "--stop-at time is not in the future: %s\n", arg);
+                                 return 0;
+                         }
+                         break;
+ #endif
+                 case OPT_STDERR: {
+                         int len;
+                         arg = poptGetOptArg(pc);
+                         len = strlen(arg);
+                         if (len && strncmp("errors", arg, len) == 0)
+                                 msgs2stderr = 2;
+                         else if (len && strncmp("all", arg, len) == 0)
+                                 msgs2stderr = 1;
+                         else if (len && strncmp("client", arg, len) == 0)
+                                 msgs2stderr = 0;
+                         else {
+                                 snprintf(err_buf, sizeof err_buf,
+                                         "--stderr mode \"%s\" is not one of errors, all, or client\n", arg);
+                                 return 0;
+                         }
+                         break;
+                 }
                  default:
                          /* A large opt value means that set_refuse_options()
                           * turned this option off. */
- Line 1274  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2167  int parse_arguments(int *argc_p, const char ***argv_p)
                  }
          }
-        if (human_readable && argc == 2 && !am_server) {
+        if (version_opt_cnt) {
+                print_rsync_version(FINFO);
+                exit_cleanup(0);
+        }
+        if (!max_alloc_arg) {
+                max_alloc_arg = getenv("RSYNC_MAX_ALLOC");
+                if (max_alloc_arg && !*max_alloc_arg)
+                        max_alloc_arg = NULL;
+        }
+        if (max_alloc_arg) {
+                ssize_t size = parse_size_arg(max_alloc_arg, 'B', "max-alloc", 1024*1024, -1, True);
+                if (size < 0)
+                        return 0;
+                max_alloc = size;
+        }
+        if (protect_args < 0) {
+                if (am_server)
+                        protect_args = 0;
+                else if ((arg = getenv("RSYNC_PROTECT_ARGS")) != NULL && *arg)
+                        protect_args = atoi(arg) ? 1 : 0;
+                else {
+#ifdef RSYNC_USE_PROTECTED_ARGS
+                        protect_args = 1;
+#else
+                        protect_args = 0;
+#endif
+                }
+        }
+        if (checksum_choice && strcasecmp(checksum_choice, "auto") != 0 && strcasecmp(checksum_choice, "auto,auto") != 0) {
+                /* Call this early to verify the args and figure out if we need to force
+                 * --whole-file. Note that the parse function will get called again later,
+                 * just in case an "auto" choice needs to know the protocol_version. */
+                parse_checksum_choice(0);
+        } else
+                checksum_choice = NULL;
+        if (human_readable > 1 && argc == 2 && !am_server) {
                  /* Allow the old meaning of 'h' (--help) on its own. */
                  usage(FINFO);
                  exit_cleanup(0);
          }
+         if (!compress_choice && do_compression > 1)
+                 compress_choice = "zlibx";
+         if (compress_choice && strcasecmp(compress_choice, "auto") != 0)
+                 parse_compress_choice(0); /* Twiddles do_compression and can possibly NULL-out compress_choice. */
+         else
+                 compress_choice = NULL;
+         if (do_compression || do_compression_level != CLVL_NOT_SPECIFIED) {
+                 if (!do_compression)
+                         do_compression = CPRES_AUTO;
+                 if (do_compression && refused_compress) {
+                         create_refuse_error(refused_compress);
+                         return 0;
+                 }
+         }
+ #ifdef HAVE_SETVBUF
+         if (outbuf_mode && !am_server) {
+                 int mode = *(uchar *)outbuf_mode;
+                 if (islower(mode))
+                         mode = toupper(mode);
+                 fflush(stdout); /* Just in case... */
+                 switch (mode) {
+                 case 'N': /* None */
+                 case 'U': /* Unbuffered */
+                         mode = _IONBF;
+                         break;
+                 case 'L': /* Line */
+                         mode = _IOLBF;
+                         break;
+                 case 'B': /* Block */
+                 case 'F': /* Full */
+                         mode = _IOFBF;
+                         break;
+                 default:
+                         snprintf(err_buf, sizeof err_buf,
+                                 "Invalid --outbuf setting -- specify N, L, or B.\n");
+                         return 0;
+                 }
+                 setvbuf(stdout, (char *)NULL, mode, 0);
+         }
+         if (msgs2stderr == 1) { /* Are all messages going to stderr? */
+                 /* Make stderr line buffered for better sharing of the stream. */
+                 fflush(stderr); /* Just in case... */
+                 setvbuf(stderr, (char *)NULL, _IOLBF, 0);
+         }
+ #endif
+         set_output_verbosity(verbose, DEFAULT_PRIORITY);
+         if (do_stats) {
+                 parse_output_words(info_words, info_levels,
+                         verbose > 1 ? "stats3" : "stats2", DEFAULT_PRIORITY);
+         }
  #ifdef ICONV_OPTION
          if (iconv_opt && protect_args != 2) {
                  if (!am_server && strcmp(iconv_opt, "-") == 0)
- Line 1293  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2281  int parse_arguments(int *argc_p, const char ***argv_p)
          }
  #endif
+         if (fuzzy_basis > 1)
+                 fuzzy_basis = basis_dir_cnt + 1;
+         /* Don't let the client reset protect_args if it was already processed */
+         if (orig_protect_args == 2 && am_server)
+                 protect_args = orig_protect_args;
          if (protect_args == 1 && am_server)
                  return 1;
- Line 1331  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2326  int parse_arguments(int *argc_p, const char ***argv_p)
          }
  #endif
+         if (!always_checksum)
+                 checksum_files = CSF_IGNORE_FILES;
+ #ifdef SUPPORT_HFS_COMPRESSION
+         if (preserve_hfs_compression) {
+                 if (!preserve_xattrs)
+                         preserve_xattrs = 1;
+                 if (!preserve_fileflags)
+                         preserve_fileflags = 1;
+         }
+ #endif
          if (write_batch && read_batch) {
                  snprintf(err_buf, sizeof err_buf,
                          "--write-batch and --read-batch can not be used together\n");
- Line 1379  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2386  int parse_arguments(int *argc_p, const char ***argv_p)
                  max_delete = 0;
          }
-         if (compare_dest + copy_dest + link_dest > 1) {
-                 snprintf(err_buf, sizeof err_buf,
-                         "You may not mix --compare-dest, --copy-dest, and --link-dest.\n");
-                 return 0;
-         }
          if (files_from) {
                  if (recurse == 1) /* preserve recurse == 2 */
                          recurse = 0;
- Line 1396  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2397  int parse_arguments(int *argc_p, const char ***argv_p)
                  list_only |= 1;
          if (xfer_dirs >= 4) {
-                parse_rule(&filter_list, "- /*/*", 0, 0);
+                parse_filter_str(&filter_list, "- /*/*", rule_template(0), 0);
                  recurse = xfer_dirs = 1;
          } else if (recurse)
                  xfer_dirs = 1;
- Line 1434  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2435  int parse_arguments(int *argc_p, const char ***argv_p)
                  return 0;
          }
-        if (delete_mode && refused_delete) {
+        if (missing_args == 3) /* simplify if both options were specified */
+                missing_args = 2;
+        if (refused_delete && (delete_mode || missing_args == 2)) {
                  create_refuse_error(refused_delete);
                  return 0;
          }
- Line 1450  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2453  int parse_arguments(int *argc_p, const char ***argv_p)
                  need_messages_from_generator = 1;
          }
+         if (munge_symlinks && !am_daemon) {
+                 STRUCT_STAT st;
+                 char prefix[SYMLINK_PREFIX_LEN]; /* NOT +1 ! */
+                 strlcpy(prefix, SYMLINK_PREFIX, sizeof prefix); /* trim the trailing slash */
+                 if (do_stat(prefix, &st) == 0 && S_ISDIR(st.st_mode)) {
+                         rprintf(FERROR, "Symlink munging is unsafe when a %s directory exists.\n",
+                                 prefix);
+                         exit_cleanup(RERR_UNSUPPORTED);
+                 }
+         }
          if (sanitize_paths) {
                  int i;
                  for (i = argc; i-- > 0; )
- Line 1458  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2472  int parse_arguments(int *argc_p, const char ***argv_p)
                          tmpdir = sanitize_path(NULL, tmpdir, NULL, 0, SP_DEFAULT);
                  if (backup_dir)
                          backup_dir = sanitize_path(NULL, backup_dir, NULL, 0, SP_DEFAULT);
+                 if (backup_dir_dels)
+                         backup_dir_dels = sanitize_path(NULL, backup_dir_dels, NULL, 0, SP_DEFAULT);
          }
          if (daemon_filter_list.head && !am_sender) {
-                struct filter_list_struct *elp = &daemon_filter_list;
+                filter_rule_list *elp = &daemon_filter_list;
                  if (tmpdir) {
                          char *dir;
                          if (!*tmpdir)
- Line 1479  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2495  int parse_arguments(int *argc_p, const char ***argv_p)
                          if (check_filter(elp, FLOG, dir, 1) < 0)
                                  goto options_rejected;
                  }
+                 /* Clean backup_dir_dels same as for backup_dir */
+                 if (backup_dir_dels) {
+                         if (!*backup_dir_dels)
+                                 goto options_rejected;
+                         clean_fname(backup_dir_dels, 1);
+                         if (check_filter(elp, FLOG, backup_dir_dels, 1) < 0)
+                                 goto options_rejected;
+                 }
          }
          if (!backup_suffix)
- Line 1490  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2514  int parse_arguments(int *argc_p, const char ***argv_p)
                          backup_suffix);
                  return 0;
          }
+         /* --suffix-dels defaults to --suffix, or empty for a client given an
+          * explicit --backup-dir-dels (just as --suffix defaults to empty when
+          * a --backup-dir is given).  The second case does not apply to the
+          * server for consistency with server_options, which sends --suffix-dels
+          * to the server iff it differs from --suffix. */
+         if (!backup_suffix_dels)
+                 backup_suffix_dels = backup_dir_dels && !am_server ? "" : backup_suffix;
+         backup_suffix_dels_len = strlen(backup_suffix_dels);
+         if (strchr(backup_suffix_dels, '/') != NULL) {
+                 snprintf(err_buf, sizeof err_buf,
+                         "--suffix-dels cannot contain slashes: %s\n",
+                         backup_suffix_dels);
+                 return 0;
+         }
          if (backup_dir) {
-                size_t len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
+                size_t len;
+                make_backups = 1; /* --backup-dir implies --backup */
+                while (*backup_dir == '.' && backup_dir[1] == '/')
+                        backup_dir += 2;
+                if (*backup_dir == '.' && backup_dir[1] == '\0')
+                        backup_dir++;
+                len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
                  if (len > sizeof backup_dir_buf - 128) {
                          snprintf(err_buf, sizeof err_buf,
                                  "the --backup-dir path is WAY too long.\n");
                          return 0;
                  }
                  backup_dir_len = (int)len;
-                if (backup_dir_buf[backup_dir_len - 1] != '/') {
+                if (!backup_dir_len) {
+                        backup_dir_len = -1;
+                        backup_dir = NULL;
+                } else if (backup_dir_buf[backup_dir_len - 1] != '/') {
                          backup_dir_buf[backup_dir_len++] = '/';
                          backup_dir_buf[backup_dir_len] = '\0';
                  }
                  backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
                 if (verbose > 1 && !am_sender)
-                        rprintf(FINFO, "backup_dir is %s\n", backup_dir_buf);
+        if (backup_dir) {
+                /* No need for a suffix or a protect rule. */
          } else if (!backup_suffix_len && (!am_server || !am_sender)) {
                  snprintf(err_buf, sizeof err_buf,
-                        "--suffix cannot be a null string without --backup-dir\n");
+                        "--suffix cannot be empty %s\n", backup_dir_len < 0
+                        ? "when --backup-dir is the same as the dest dir"
+                        : "without a --backup-dir");
                  return 0;
          } else if (make_backups && delete_mode && !delete_excluded && !am_server) {
                  snprintf(backup_dir_buf, sizeof backup_dir_buf,
                          "P *%s", backup_suffix);
-                parse_rule(&filter_list, backup_dir_buf, 0, 0);
+                parse_filter_str(&filter_list, backup_dir_buf, rule_template(0), 0);
          }
+         if (backup_dir_dels) {
+                 backup_dir_dels_len = strlcpy(backup_dir_dels_buf, backup_dir_dels, sizeof backup_dir_dels_buf);
+                 backup_dir_dels_remainder = sizeof backup_dir_dels_buf - backup_dir_dels_len;
+                 if (backup_dir_dels_remainder < 32) {
+                         snprintf(err_buf, sizeof err_buf,
+                                 "the --backup-dir-dels path is WAY too long.\n");
+                         return 0;
+                 }
+                 if (backup_dir_dels_buf[backup_dir_dels_len - 1] != '/') {
+                         backup_dir_dels_buf[backup_dir_dels_len++] = '/';
+                         backup_dir_dels_buf[backup_dir_dels_len] = '\0';
+                 }
+                 if (INFO_GTE(BACKUP, 1) && !am_sender)
+                         rprintf(FINFO, "backup_dir_dels is %s\n", backup_dir_dels_buf);
+         } else if (backup_dir) {
+                 backup_dir_dels = backup_dir;
+                 backup_dir_dels_len = backup_dir_len;
+                 backup_dir_dels_remainder = backup_dir_remainder;
+                 strlcpy(backup_dir_dels_buf, backup_dir_buf, sizeof backup_dir_buf);
+         } else if (!backup_suffix_dels_len && (!am_server || !am_sender)) {
+                 snprintf(err_buf, sizeof err_buf,
+                         "--suffix-dels cannot be a null string without --backup-dir-dels\n");
+                 return 0;
+         } else if (make_backups && delete_mode && !delete_excluded && !am_server) {
+                 snprintf(backup_dir_dels_buf, sizeof backup_dir_dels_buf,
+                         "P *%s", backup_suffix_dels);
+                 parse_filter_str(&filter_list, backup_dir_dels_buf, rule_template(0), 0);
+         }
+         if (omit_dir_changes)
+                 omit_dir_times = 1;
          if (preserve_times) {
                  preserve_times = PRESERVE_FILE_TIMES;
                  if (!omit_dir_times)
                          preserve_times |= PRESERVE_DIR_TIMES;
  #ifdef CAN_SET_SYMLINK_TIMES
-                preserve_times |= PRESERVE_LINK_TIMES;
+                if (!omit_link_times)
+                        preserve_times |= PRESERVE_LINK_TIMES;
  #endif
          }
- Line 1535  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2617  int parse_arguments(int *argc_p, const char ***argv_p)
                  else if (log_format_has(stdout_format, 'i'))
                          stdout_format_has_i = itemize_changes | 1;
                  if (!log_format_has(stdout_format, 'b')
-                 && !log_format_has(stdout_format, 'c'))
+                 && !log_format_has(stdout_format, 'c')
+                 && !log_format_has(stdout_format, 'C'))
                          log_before_transfer = !am_server;
          } else if (itemize_changes) {
                  stdout_format = "%i %n%L";
- Line 1543  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2626  int parse_arguments(int *argc_p, const char ***argv_p)
                  log_before_transfer = !am_server;
          }
-        if (do_progress && !verbose && !log_before_transfer && !am_server)
+        if (do_progress && !am_server) {
-                verbose = 1;
+                if (!log_before_transfer && INFO_EQ(NAME, 0))
+                        parse_output_words(info_words, info_levels, "name", DEFAULT_PRIORITY);
+                parse_output_words(info_words, info_levels, "flist2,progress", DEFAULT_PRIORITY);
+        }
          if (dry_run)
                  do_xfers = 0;
          set_io_timeout(io_timeout);
-        if (verbose && !stdout_format) {
+        if (INFO_GTE(NAME, 1) && !stdout_format) {
                  stdout_format = "%n%L";
                  log_before_transfer = !am_server;
          }
- Line 1580  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2666  int parse_arguments(int *argc_p, const char ***argv_p)
                          bwlimit_writemax = 512;
          }
-         if (sparse_files && inplace) {
-                 /* Note: we don't check for this below, because --append is
-                  * OK with --sparse (as long as redos are handled right). */
-                 snprintf(err_buf, sizeof err_buf,
-                          "--sparse cannot be used with --inplace\n");
-                 return 0;
-         }
          if (append_mode) {
                  if (whole_file > 0) {
                          snprintf(err_buf, sizeof err_buf,
- Line 1601  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2679  int parse_arguments(int *argc_p, const char ***argv_p)
                  inplace = 1;
          }
-        if (delay_updates && !partial_dir)
+        if (write_devices) {
+                if (refused_inplace) {
+                        create_refuse_error(refused_inplace);
+                        return 0;
+                }
+                inplace = 1;
+        }
+        if ((delay_updates || detect_renamed) && !partial_dir)
                  partial_dir = tmp_partialdir;
          if (inplace) {
- Line 1610  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2696  int parse_arguments(int *argc_p, const char ***argv_p)
                          snprintf(err_buf, sizeof err_buf,
                                   "--%s cannot be used with --%s\n",
                                   append_mode ? "append" : "inplace",
+                                  detect_renamed ? "detect-renamed" :
                                   delay_updates ? "delay-updates" : "partial-dir");
                          return 0;
                  }
- Line 1645  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2732  int parse_arguments(int *argc_p, const char ***argv_p)
                  }
          }
+         if (source_filter || dest_filter) {
+                 if (whole_file == 0) {
+                         snprintf(err_buf, sizeof err_buf,
+                                  "--no-whole-file cannot be used with --%s-filter\n",
+                                  source_filter ? "source" : "dest");
+                         return 0;
+                 }
+                 whole_file = 1;
+         }
          if (files_from) {
                  char *h, *p;
                  int q;
-                if (argc > 2 || (!am_daemon && argc == 1)) {
+                if (argc > 2 || (!am_daemon && !am_server && argc == 1)) {
                          usage(FERROR);
                          exit_cleanup(RERR_SYNTAX);
                  }
- Line 1691  int parse_arguments(int *argc_p, const char ***argv_p)
+ Line 2788  int parse_arguments(int *argc_p, const char ***argv_p)
                  }
          }
+         if (tr_opt) {
+                 if (*tr_opt == '/' && tr_opt[1]) {
+                         snprintf(err_buf, sizeof err_buf,
+                                 "Do not start the --tr arg with a slash\n");
+                         return 0;
+                 }
+                 if (*tr_opt && *tr_opt != '/') {
+                         need_unsorted_flist = 1;
+                         arg = strchr(tr_opt, '/');
+                         if (arg && strchr(arg+1, '/')) {
+                                 snprintf(err_buf, sizeof err_buf,
+                                         "--tr cannot transliterate slashes\n");
+                                 return 0;
+                         }
+                 } else
+                         tr_opt = NULL;
+         }
          am_starting_up = 0;
          return 1;
- Line 1714  void server_options(char **args, int *argc_p)
+ Line 2829  void server_options(char **args, int *argc_p)
  {
          static char argstr[64];
          int ac = *argc_p;
+         uchar where;
          char *arg;
          int i, x;
          /* This should always remain first on the server's command-line. */
          args[ac++] = "--server";
-         if (daemon_over_rsh > 0) {
-                 args[ac++] = "--daemon";
-                 *argc_p = ac;
-                 /* if we're passing --daemon, we're done */
-                 return;
-         }
          if (!am_sender)
                  args[ac++] = "--sender";
- Line 1739  void server_options(char **args, int *argc_p)
+ Line 2848  void server_options(char **args, int *argc_p)
          for (i = 0; i < verbose; i++)
                  argstr[x++] = 'v';
-        /* the -q option is intentionally left out */
+        if (quiet && msgs2stderr)
+                argstr[x++] = 'q';
          if (make_backups)
                  argstr[x++] = 'b';
          if (update_only)
- Line 1758  void server_options(char **args, int *argc_p)
+ Line 2868  void server_options(char **args, int *argc_p)
                          argstr[x++] = 'm';
                  if (omit_dir_times)
                          argstr[x++] = 'O';
+                 if (omit_link_times)
+                         argstr[x++] = 'J';
+                 if (omit_dir_changes == 1)
+                         args[ac++] = "--omit-dir-changes";
+                 if (fuzzy_basis) {
+                         argstr[x++] = 'y';
+                         if (fuzzy_basis > 1)
+                                 argstr[x++] = 'y';
+                 }
          } else {
                  if (copy_links)
                          argstr[x++] = 'L';
- Line 1784  void server_options(char **args, int *argc_p)
+ Line 2903  void server_options(char **args, int *argc_p)
                  argstr[x++] = 'D';
          if (preserve_times)
                  argstr[x++] = 't';
+         if (preserve_atimes) {
+                 argstr[x++] = 'U';
+                 if (preserve_atimes > 1)
+                         argstr[x++] = 'U';
+         }
+ #ifdef SUPPORT_CRTIMES
+         if (preserve_crtimes)
+                 argstr[x++] = 'N';
+ #endif
          if (preserve_perms)
                  argstr[x++] = 'p';
          else if (preserve_executability && am_sender)
- Line 1816  void server_options(char **args, int *argc_p)
+ Line 2944  void server_options(char **args, int *argc_p)
          }
          if (sparse_files)
                  argstr[x++] = 'S';
-        if (do_compression)
+        if (do_compression == CPRES_ZLIB)
                  argstr[x++] = 'z';
          set_allow_inc_recurse();
-        /* Checking the pre-negotiated value allows --protocol=29 override. */
+        /* We don't really know the actual protocol_version at this point,
+         * but checking the pre-negotiated value allows the user to use a
+         * --protocol=29 override to avoid the use of this -eFLAGS opt. */
          if (protocol_version >= 30) {
+                 /* Use "eFlags" alias so that cull_options doesn't think that these are no-arg option letters. */
+ #define eFlags argstr
                  /* We make use of the -e option to let the server know about
                   * any pre-release protocol version && some behavior flags. */
-                argstr[x++] = 'e';
+                eFlags[x++] = 'e';
  #if SUBPROTOCOL_VERSION != 0
                  if (protocol_version == PROTOCOL_VERSION) {
                          x += snprintf(argstr+x, sizeof argstr - x,
- Line 1833  void server_options(char **args, int *argc_p)
+ Line 2965  void server_options(char **args, int *argc_p)
                                        PROTOCOL_VERSION, SUBPROTOCOL_VERSION);
                  } else
  #endif
-                        argstr[x++] = '.';
+                        eFlags[x++] = '.';
                  if (allow_inc_recurse)
-                        argstr[x++] = 'i';
+                        eFlags[x++] = 'i';
  #ifdef CAN_SET_SYMLINK_TIMES
-                argstr[x++] = 'L';
+                eFlags[x++] = 'L'; /* symlink time-setting support */
  #endif
  #ifdef ICONV_OPTION
-                argstr[x++] = 's';
+                eFlags[x++] = 's'; /* symlink iconv translation support */
  #endif
-                argstr[x++] = 'f';
+                eFlags[x++] = 'f'; /* flist I/O-error safety support */
+                eFlags[x++] = 'x'; /* xattr hardlink optimization not desired */
+                eFlags[x++] = 'C'; /* support checksum seed order fix */
+                eFlags[x++] = 'I'; /* support inplace_partial behavior */
+                eFlags[x++] = 'v'; /* use varint for flist & compat flags; negotiate checksum */
+                eFlags[x++] = 'u'; /* include name of uid 0 & gid 0 in the id map */
+                /* NOTE: Avoid using 'V' -- it was the high bit of a write_byte() that became write_varint(). */
+#undef eFlags
          }
          if (x >= (int)sizeof argstr) { /* Not possible... */
- Line 1879  void server_options(char **args, int *argc_p)
+ Line 3018  void server_options(char **args, int *argc_p)
          if (xfer_dirs && !recurse && delete_mode && am_sender)
                  args[ac++] = "--no-r";
-        if (do_compression && def_compress_level != Z_DEFAULT_COMPRESSION) {
+        if (preserve_fileflags)
-                if (asprintf(&arg, "--compress-level=%d", def_compress_level) < 0)
+                args[ac++] = "--fileflags";
+#ifdef SUPPORT_HFS_COMPRESSION
+        if (preserve_hfs_compression)
+                args[ac++] = preserve_hfs_compression == 1 ? "--hfs-compression" : "--protect-decmpfs";
+#endif
+        if (do_compression && do_compression_level != CLVL_NOT_SPECIFIED) {
+                if (asprintf(&arg, "--compress-level=%d", do_compression_level) < 0)
                          goto oom;
                  args[ac++] = arg;
          }
- Line 1906  void server_options(char **args, int *argc_p)
+ Line 3053  void server_options(char **args, int *argc_p)
                          args[ac++] = "--log-format=X";
          }
+         if (msgs2stderr == 1)
+                 args[ac++] = "--msgs2stderr";
+         else if (msgs2stderr == 0)
+                 args[ac++] = "--no-msgs2stderr";
          if (block_size) {
-                if (asprintf(&arg, "-B%lu", block_size) < 0)
+                if (asprintf(&arg, "-B%u", (int)block_size) < 0)
                          goto oom;
                  args[ac++] = arg;
          }
+         if (sparse_files_block_size) {
+                 if (asprintf(&arg, "--sparse-block=%lu", sparse_files_block_size) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
          if (io_timeout) {
                  if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
                          goto oom;
- Line 1928  void server_options(char **args, int *argc_p)
+ Line 3086  void server_options(char **args, int *argc_p)
                  args[ac++] = "--backup-dir";
                  args[ac++] = backup_dir;
          }
+         if (backup_dir_dels && backup_dir_dels != backup_dir) {
+                 args[ac++] = "--backup-dir-dels";
+                 args[ac++] = backup_dir_dels;
+         }
          /* Only send --suffix if it specifies a non-default value. */
          if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
- Line 1936  void server_options(char **args, int *argc_p)
+ Line 3098  void server_options(char **args, int *argc_p)
                          goto oom;
                  args[ac++] = arg;
          }
+         /* Only send --suffix-dels if it specifies a value different from the
+          * --suffix value, which would normally be used for deletions too. */
+         if (strcmp(backup_suffix_dels, backup_suffix) != 0) {
+                 /* We use the following syntax to avoid weirdness with '~'. */
+                 if (asprintf(&arg, "--suffix-dels=%s", backup_suffix_dels) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
+         if (checksum_choice) {
+                 if (asprintf(&arg, "--checksum-choice=%s", checksum_choice) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
+         if (do_compression == CPRES_ZLIBX)
+                 args[ac++] = "--new-compress";
+         else if (compress_choice && do_compression == CPRES_ZLIB)
+                 args[ac++] = "--old-compress";
+         else if (compress_choice) {
+                 if (asprintf(&arg, "--compress-choice=%s", compress_choice) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
          if (am_sender) {
+                 /* A remote sender just needs the above -b option.
+                  * A remote receiver will override that with this option. */
+                 if (make_backups == 1)
+                         args[ac++] = "--backup-deleted";
                  if (max_delete > 0) {
                          if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
                                  goto oom;
                          args[ac++] = arg;
                  } else if (max_delete == 0)
                          args[ac++] = "--max-delete=-1";
-                if (min_size) {
+                if (min_size >= 0) {
                          args[ac++] = "--min-size";
                          args[ac++] = min_size_arg;
                  }
-                if (max_size) {
+                if (max_size >= 0) {
                          args[ac++] = "--max-size";
                          args[ac++] = max_size_arg;
                  }
- Line 1966  void server_options(char **args, int *argc_p)
+ Line 3156  void server_options(char **args, int *argc_p)
                          args[ac++] = "--delete-excluded";
                  if (force_delete)
                          args[ac++] = "--force";
+ #ifdef SUPPORT_FORCE_CHANGE
+                 if (force_change) {
+                         if (force_change == ALL_IMMUTABLE)
+                                 args[ac++] = "--force-change";
+                         else if (force_change == USR_IMMUTABLE)
+                                 args[ac++] = "--force-uchange";
+                         else if (force_change == SYS_IMMUTABLE)
+                                 args[ac++] = "--force-schange";
+                 }
+ #endif
                  if (write_batch < 0)
                          args[ac++] = "--only-write-batch=X";
                  if (am_root > 1)
                          args[ac++] = "--super";
                  if (size_only)
                          args[ac++] = "--size-only";
+                 if (detect_renamed)
+                         args[ac++] = "--detect-renamed";
+                 if (do_stats)
+                         args[ac++] = "--stats";
          } else {
                  if (skip_compress) {
                          if (asprintf(&arg, "--skip-compress=%s", skip_compress) < 0)
                                  goto oom;
                          args[ac++] = arg;
                  }
+                 if (make_source_backups)
+                         args[ac++] = "--source-backup";
          }
-        if (modify_window_set) {
+        if (max_alloc_arg && max_alloc != DEFAULT_MAX_ALLOC) {
-                if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
+                args[ac++] = "--max-alloc";
+                args[ac++] = max_alloc_arg;
+        }
+        /* --delete-missing-args needs the cooperation of both sides, but
+         * the sender can handle --ignore-missing-args by itself. */
+        if (missing_args == 2)
+                args[ac++] = "--delete-missing-args";
+        else if (missing_args == 1 && !am_sender)
+                args[ac++] = "--ignore-missing-args";
+        if (date_only)
+                args[ac++] = "--date-only";
+        if (times_only && am_sender)
+                args[ac++] = "--times-only";
+        if (source_filter && !am_sender) {
+                /* Need to single quote the arg to keep the remote shell
+                 * from splitting it.  FIXME: breaks if command has single quotes. */
+                if (asprintf(&arg, "--source-filter='%s'", source_filter) < 0)
                          goto oom;
                  args[ac++] = arg;
          }
+         if (dest_filter && am_sender) {
+                 /* Need to single quote the arg to keep the remote shell
+                  * from splitting it.  FIXME: breaks if command has single quotes. */
+                 if (asprintf(&arg, "--dest-filter='%s'", dest_filter) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
+         if (modify_window_set && am_sender) {
+                 char *fmt = modify_window < 0 ? "-@%d" : "--modify-window=%d";
+                 if (asprintf(&arg, fmt, modify_window) < 0)
+                         goto oom;
+                 args[ac++] = arg;
+         }
          if (checksum_seed) {
                  if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
                          goto oom;
                  args[ac++] = arg;
          }
+         if (ignore_case)
+                 args[ac++] = "--ignore-case";
          if (partial_dir && am_sender) {
                  if (partial_dir != tmp_partialdir) {
                          args[ac++] = "--partial-dir";
- Line 2018  void server_options(char **args, int *argc_p)
+ Line 3262  void server_options(char **args, int *argc_p)
                  args[ac++] = "--use-qsort";
          if (am_sender) {
+                 if (usermap) {
+                         if (asprintf(&arg, "--usermap=%s", usermap) < 0)
+                                 goto oom;
+                         args[ac++] = arg;
+                 }
+                 if (groupmap) {
+                         if (asprintf(&arg, "--groupmap=%s", groupmap) < 0)
+                                 goto oom;
+                         args[ac++] = arg;
+                 }
                  if (ignore_existing)
                          args[ac++] = "--ignore-existing";
- Line 2030  void server_options(char **args, int *argc_p)
+ Line 3286  void server_options(char **args, int *argc_p)
                          args[ac++] = tmpdir;
                  }
+                 if (do_fsync)
+                         args[ac++] = "--fsync";
                  if (basis_dir[0]) {
                          /* the server only needs this option if it is not the sender,
                           *   and it may be an older version that doesn't know this
                           *   option, so don't send it if client is the sender.
                           */
                          for (i = 0; i < basis_dir_cnt; i++) {
-                                args[ac++] = dest_option;
+                                args[ac++] = alt_dest_opt(0);
                                  args[ac++] = basis_dir[i];
                          }
                  }
          }
+         /* What flags do we need to send to the other side? */
+         where = (am_server ? W_CLI : W_SRV) | (am_sender ? W_REC : W_SND);
+         arg = make_output_option(info_words, info_levels, where);
+         if (arg)
+                 args[ac++] = arg;
          if (append_mode) {
                  if (append_mode > 1)
                          args[ac++] = "--append";
- Line 2049  void server_options(char **args, int *argc_p)
+ Line 3314  void server_options(char **args, int *argc_p)
          } else if (inplace)
                  args[ac++] = "--inplace";
+         if (link_by_hash_dir && am_sender) {
+                 args[ac++] = "--link-by-hash";
+                 args[ac++] = link_by_hash_dir;
+                 link_by_hash_dir = NULL; /* optimize sending-side checksums */
+         }
          if (files_from && (!am_sender || filesfrom_host)) {
                  if (filesfrom_host) {
                          args[ac++] = "--files-from";
- Line 2066  void server_options(char **args, int *argc_p)
+ Line 3337  void server_options(char **args, int *argc_p)
          if (relative_paths && !implied_dirs && (!am_sender || protocol_version >= 30))
                  args[ac++] = "--no-implied-dirs";
-        if (fuzzy_basis && am_sender)
+        if (tr_opt) {
-                args[ac++] = "--fuzzy";
+                if (asprintf(&arg, "--tr=%s", tr_opt) < 0)
+                        goto oom;
+                args[ac++] = arg;
+        }
+         if (write_devices && am_sender)
+                 args[ac++] = "--write-devices";
          if (remove_source_files == 1)
                  args[ac++] = "--remove-source-files";
          else if (remove_source_files)
                  args[ac++] = "--remove-sent-files";
+         if (copy_devices)
+                 args[ac++] = "--copy-devices";
+         if (preallocate_files && am_sender)
+                 args[ac++] = "--preallocate";
+         if (open_noatime && preserve_atimes <= 1)
+                 args[ac++] = "--open-noatime";
+         if (mkpath_dest_arg && am_sender)
+                 args[ac++] = "--mkpath";
          if (ac > MAX_SERVER_ARGS) { /* Not possible... */
                  rprintf(FERROR, "argc overflow in server_options().\n");
                  exit_cleanup(RERR_MALLOC);
          }
+         if (remote_option_cnt) {
+                 int j;
+                 if (ac + remote_option_cnt > MAX_SERVER_ARGS) {
+                         rprintf(FERROR, "too many remote options specified.\n");
+                         exit_cleanup(RERR_SYNTAX);
+                 }
+                 for (j = 1; j <= remote_option_cnt; j++)
+                         args[ac++] = (char*)remote_options[j];
+         }
          *argc_p = ac;
          return;
- Line 2142  static char *parse_hostspec(char *str, char **path_sta
+ Line 3441  static char *parse_hostspec(char *str, char **path_sta
          return ret;
  }
-/* Look for a HOST specfication of the form "HOST:PATH", "HOST::PATH", or
+/* Look for a HOST specification of the form "HOST:PATH", "HOST::PATH", or
   * "rsync://HOST:PORT/PATH".  If found, *host_ptr will be set to some allocated
   * memory with the HOST.  If a daemon-accessing spec was specified, the value
   * of *port_ptr will contain a non-0 port number, otherwise it will be set to
- Line 2157  char *check_for_hostspec(char *s, char **host_ptr, int
+ Line 3456  char *check_for_hostspec(char *s, char **host_ptr, int
                  *host_ptr = parse_hostspec(s + strlen(URL_PREFIX), &path, port_ptr);
                  if (*host_ptr) {
                          if (!*port_ptr)
-                                *port_ptr = RSYNC_PORT;
+                                *port_ptr = -1; /* -1 indicates they want the default */
                          return path;
                  }
          }
- Line 2168  char *check_for_hostspec(char *s, char **host_ptr, int
+ Line 3467  char *check_for_hostspec(char *s, char **host_ptr, int
          if (*path == ':') {
                  if (port_ptr && !*port_ptr)
-                        *port_ptr = RSYNC_PORT;
+                        *port_ptr = -1;
                  return path + 1;
          }
          if (port_ptr)

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.4