options.c

   1 /*  -*- c-file-style: "linux" -*-
   2  *
   3  * Copyright (C) 1998-2001 by Andrew Tridgell <tridge@samba.org>
   4  * Copyright (C) 2000, 2001, 2002 by Martin Pool <mbp@samba.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "rsync.h"
  22 #include "popt.h"
  23
  24 extern int module_id;
  25 extern int sanitize_paths;
  26 extern int select_timeout;
  27 extern struct filter_list_struct filter_list;
  28 extern struct filter_list_struct server_filter_list;
  29
  30 int make_backups = 0;
  31
  32 /**
  33  * If 1, send the whole file as literal data rather than trying to
  34  * create an incremental diff.
  35  *
  36  * If -1, then look at whether we're local or remote and go by that.
  37  *
  38  * @sa disable_deltas_p()
  39  **/
  40 int whole_file = -1;
  41
  42 int archive_mode = 0;
  43 int keep_dirlinks = 0;
  44 int copy_links = 0;
  45 int preserve_links = 0;
  46 int preserve_hard_links = 0;
  47 int preserve_perms = 0;
  48 int preserve_devices = 0;
  49 int preserve_uid = 0;
  50 int preserve_gid = 0;
  51 int preserve_times = 0;
  52 int omit_dir_times = 0;
  53 int update_only = 0;
  54 int cvs_exclude = 0;
  55 int dry_run = 0;
  56 int ignore_times = 0;
  57 int delete_mode = 0;
  58 int delete_during = 0;
  59 int delete_before = 0;
  60 int delete_after = 0;
  61 int delete_excluded = 0;
  62 int remove_sent_files = 0;
  63 int one_file_system = 0;
  64 int protocol_version = PROTOCOL_VERSION;
  65 int sparse_files = 0;
  66 int do_compression = 0;
  67 int am_root = 0;
  68 int orig_umask = 0;
  69 int relative_paths = -1;
  70 int implied_dirs = 1;
  71 int numeric_ids = 0;
  72 int force_delete = 0;
  73 int io_timeout = 0;
  74 int am_server = 0;
  75 int am_sender = -1;
  76 int am_generator = 0;
  77 char *files_from = NULL;
  78 int filesfrom_fd = -1;
  79 char *remote_filesfrom_file = NULL;
  80 int eol_nulls = 0;
  81 int recurse = 0;
  82 int xfer_dirs = 0;
  83 int am_daemon = 0;
  84 int daemon_over_rsh = 0;
  85 int do_stats = 0;
  86 int do_progress = 0;
  87 int keep_partial = 0;
  88 int safe_symlinks = 0;
  89 int copy_unsafe_links = 0;
  90 int size_only = 0;
  91 int daemon_bwlimit = 0;
  92 int bwlimit = 0;
  93 int fuzzy_basis = 0;
  94 size_t bwlimit_writemax = 0;
  95 int only_existing = 0;
  96 int opt_ignore_existing = 0;
  97 int need_messages_from_generator = 0;
  98 int max_delete = 0;
  99 OFF_T max_size = 0;
 100 int ignore_errors = 0;
 101 int modify_window = 0;
 102 int blocking_io = -1;
 103 int checksum_seed = 0;
 104 int inplace = 0;
 105 int delay_updates = 0;
 106 long block_size = 0; /* "long" because popt can't set an int32. */
 107
 108
 109 /** Network address family. **/
 110 #ifdef INET6
 111 int default_af_hint = 0;        /* Any protocol */
 112 #else
 113 int default_af_hint = AF_INET;  /* Must use IPv4 */
 114 #endif
 115
 116 /** Do not go into the background when run as --daemon.  Good
 117  * for debugging and required for running as a service on W32,
 118  * or under Unix process-monitors. **/
 119 int no_detach
 120 #if defined _WIN32 || defined __WIN32__
 121         = 1;
 122 #else
 123         = 0;
 124 #endif
 125
 126 int write_batch = 0;
 127 int read_batch = 0;
 128 int backup_dir_len = 0;
 129 int backup_suffix_len;
 130 unsigned int backup_dir_remainder;
 131
 132 char *backup_suffix = NULL;
 133 char *tmpdir = NULL;
 134 char *partial_dir = NULL;
 135 char *basis_dir[MAX_BASIS_DIRS+1];
 136 char *config_file = NULL;
 137 char *shell_cmd = NULL;
 138 char *log_format = NULL;
 139 char *password_file = NULL;
 140 char *rsync_path = RSYNC_PATH;
 141 char *backup_dir = NULL;
 142 char backup_dir_buf[MAXPATHLEN];
 143 int rsync_port = 0;
 144 int compare_dest = 0;
 145 int copy_dest = 0;
 146 int link_dest = 0;
 147 int basis_dir_cnt = 0;
 148
 149 int verbose = 0;
 150 int quiet = 0;
 151 int itemize_changes = 0;
 152 int log_before_transfer = 0;
 153 int log_format_has_i = 0;
 154 int log_format_has_o_or_i = 0;
 155 int always_checksum = 0;
 156 int list_only = 0;
 157
 158 #define MAX_BATCH_NAME_LEN 256  /* Must be less than MAXPATHLEN-13 */
 159 char *batch_name = NULL;
 160
 161 static int daemon_opt;   /* sets am_daemon after option error-reporting */
 162 static int F_option_cnt = 0;
 163 static int modify_window_set;
 164 static int refused_delete, refused_archive_part;
 165 static int refused_partial, refused_progress, refused_delete_before;
 166 static char *dest_option = NULL;
 167 static char *max_size_arg;
 168 static char partialdir_for_delayupdate[] = ".~tmp~";
 169
 170 /** Local address to bind.  As a character string because it's
 171  * interpreted by the IPv6 layer: should be a numeric IP4 or IP6
 172  * address, or a hostname. **/
 173 char *bind_address;
 174
 175
 176 static void print_rsync_version(enum logcode f)
 177 {
 178         char const *got_socketpair = "no ";
 179         char const *have_inplace = "no ";
 180         char const *hardlinks = "no ";
 181         char const *links = "no ";
 182         char const *ipv6 = "no ";
 183         STRUCT_STAT *dumstat;
 184
 185 #ifdef HAVE_SOCKETPAIR
 186         got_socketpair = "";
 187 #endif
 188
 189 #ifdef HAVE_FTRUNCATE
 190         have_inplace = "";
 191 #endif
 192
 193 #ifdef SUPPORT_HARD_LINKS
 194         hardlinks = "";
 195 #endif
 196
 197 #ifdef SUPPORT_LINKS
 198         links = "";
 199 #endif
 200
 201 #ifdef INET6
 202         ipv6 = "";
 203 #endif
 204
 205         rprintf(f, "%s  version %s  protocol version %d\n",
 206                 RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION);
 207         rprintf(f,
 208                 "Copyright (C) 1996-2005 by Andrew Tridgell and others\n");
 209         rprintf(f, "<http://rsync.samba.org/>\n");
 210         rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, "
 211                 "%shard links, %ssymlinks, batchfiles, \n",
 212                 (int) (sizeof (OFF_T) * 8),
 213                 got_socketpair, hardlinks, links);
 214
 215         /* Note that this field may not have type ino_t.  It depends
 216          * on the complicated interaction between largefile feature
 217          * macros. */
 218         rprintf(f, "              %sinplace, %sIPv6, %d-bit system inums, %d-bit internal inums\n",
 219                 have_inplace, ipv6,
 220                 (int) (sizeof dumstat->st_ino * 8),
 221                 (int) (sizeof (int64) * 8));
 222 #ifdef MAINTAINER_MODE
 223         rprintf(f, "              panic action: \"%s\"\n",
 224                 get_panic_action());
 225 #endif
 226
 227 #if SIZEOF_INT64 < 8
 228         rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
 229 #endif
 230         if (sizeof (int64) != SIZEOF_INT64) {
 231                 rprintf(f,
 232                         "WARNING: size mismatch in SIZEOF_INT64 define (%d != %d)\n",
 233                         (int) SIZEOF_INT64, (int) sizeof (int64));
 234         }
 235
 236         rprintf(f,
 237 "\n"
 238 "rsync comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n"
 239 "are welcome to redistribute it under certain conditions.  See the GNU\n"
 240 "General Public Licence for details.\n"
 241                 );
 242 }
 243
 244
 245 void usage(enum logcode F)
 246 {
 247   print_rsync_version(F);
 248
 249   rprintf(F,"\nrsync is a file transfer program capable of efficient remote update\nvia a fast differencing algorithm.\n\n");
 250
 251   rprintf(F,"Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST\n");
 252   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST:SRC DEST\n");
 253   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... DEST\n");
 254   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]\n");
 255   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST\n");
 256   rprintf(F,"  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]\n");
 257   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST\n");
 258   rprintf(F,"SRC on single-colon remote HOST will be expanded by remote shell\n");
 259   rprintf(F,"SRC on server remote HOST may contain shell wildcards or multiple\n");
 260   rprintf(F,"  sources separated by space as long as they have same top-level\n");
 261   rprintf(F,"\nOptions\n");
 262   rprintf(F," -v, --verbose               increase verbosity\n");
 263   rprintf(F," -q, --quiet                 suppress non-error messages\n");
 264   rprintf(F," -c, --checksum              skip based on checksum, not mod-time & size\n");
 265   rprintf(F," -a, --archive               archive mode; same as -rlptgoD (no -H)\n");
 266   rprintf(F," -r, --recursive             recurse into directories\n");
 267   rprintf(F," -R, --relative              use relative path names\n");
 268   rprintf(F,"     --no-relative           turn off --relative\n");
 269   rprintf(F,"     --no-implied-dirs       don't send implied dirs with -R\n");
 270   rprintf(F," -b, --backup                make backups (see --suffix & --backup-dir)\n");
 271   rprintf(F,"     --backup-dir=DIR        make backups into hierarchy based in DIR\n");
 272   rprintf(F,"     --suffix=SUFFIX         set backup suffix (default %s w/o --backup-dir)\n",BACKUP_SUFFIX);
 273   rprintf(F," -u, --update                skip files that are newer on the receiver\n");
 274   rprintf(F,"     --inplace               update destination files in-place (SEE MAN PAGE)\n");
 275   rprintf(F," -d, --dirs                  transfer directories without recursing\n");
 276   rprintf(F," -l, --links                 copy symlinks as symlinks\n");
 277   rprintf(F," -L, --copy-links            transform symlink into referent file/dir\n");
 278   rprintf(F,"     --copy-unsafe-links     only \"unsafe\" symlinks are transformed\n");
 279   rprintf(F,"     --safe-links            ignore symlinks that point outside the source tree\n");
 280   rprintf(F," -H, --hard-links            preserve hard links\n");
 281   rprintf(F," -K, --keep-dirlinks         treat symlinked dir on receiver as dir\n");
 282   rprintf(F," -p, --perms                 preserve permissions\n");
 283   rprintf(F," -o, --owner                 preserve owner (root only)\n");
 284   rprintf(F," -g, --group                 preserve group\n");
 285   rprintf(F," -D, --devices               preserve devices (root only)\n");
 286   rprintf(F," -t, --times                 preserve times\n");
 287   rprintf(F," -O, --omit-dir-times        omit directories when preserving times\n");
 288   rprintf(F," -S, --sparse                handle sparse files efficiently\n");
 289   rprintf(F," -n, --dry-run               show what would have been transferred\n");
 290   rprintf(F," -W, --whole-file            copy files whole (without rsync algorithm)\n");
 291   rprintf(F,"     --no-whole-file         always use incremental rsync algorithm\n");
 292   rprintf(F," -x, --one-file-system       don't cross filesystem boundaries\n");
 293   rprintf(F," -B, --block-size=SIZE       force a fixed checksum block-size\n");
 294   rprintf(F," -e, --rsh=COMMAND           specify the remote shell to use\n");
 295   rprintf(F,"     --rsync-path=PATH       specify path to rsync on the remote machine\n");
 296   rprintf(F,"     --existing              only update files that already exist on receiver\n");
 297   rprintf(F,"     --ignore-existing       ignore files that already exist on receiving side\n");
 298   rprintf(F,"     --remove-sent-files     sent files/symlinks are removed from sending side\n");
 299   rprintf(F,"     --del                   an alias for --delete-during\n");
 300   rprintf(F,"     --delete                delete files that don't exist on the sending side\n");
 301   rprintf(F,"     --delete-before         receiver deletes before transfer (default)\n");
 302   rprintf(F,"     --delete-during         receiver deletes during transfer, not before\n");
 303   rprintf(F,"     --delete-after          receiver deletes after transfer, not before\n");
 304   rprintf(F,"     --delete-excluded       also delete excluded files on the receiving side\n");
 305   rprintf(F,"     --ignore-errors         delete even if there are I/O errors\n");
 306   rprintf(F,"     --force                 force deletion of directories even if not empty\n");
 307   rprintf(F,"     --max-delete=NUM        don't delete more than NUM files\n");
 308   rprintf(F,"     --max-size=SIZE         don't transfer any file larger than SIZE\n");
 309   rprintf(F,"     --partial               keep partially transferred files\n");
 310   rprintf(F,"     --partial-dir=DIR       put a partially transferred file into DIR\n");
 311   rprintf(F,"     --delay-updates         put all updated files into place at transfer's end\n");
 312   rprintf(F,"     --numeric-ids           don't map uid/gid values by user/group name\n");
 313   rprintf(F,"     --timeout=TIME          set I/O timeout in seconds\n");
 314   rprintf(F," -I, --ignore-times          don't skip files that match in size and mod-time\n");
 315   rprintf(F,"     --size-only             skip files that match in size\n");
 316   rprintf(F,"     --modify-window=NUM     compare mod-times with reduced accuracy\n");
 317   rprintf(F," -T, --temp-dir=DIR          create temporary files in directory DIR\n");
 318   rprintf(F," -y, --fuzzy                 find similar file for basis if no dest file\n");
 319   rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
 320   rprintf(F,"     --copy-dest=DIR         ... and include copies of unchanged files\n");
 321   rprintf(F,"     --link-dest=DIR         hardlink to files in DIR when unchanged\n");
 322   rprintf(F," -z, --compress              compress file data during the transfer\n");
 323   rprintf(F," -C, --cvs-exclude           auto-ignore files the same way CVS does\n");
 324   rprintf(F," -f, --filter=RULE           add a file-filtering RULE\n");
 325   rprintf(F," -F                          same as --filter='dir-merge /.rsync-filter'\n");
 326   rprintf(F,"                             repeated: --filter='- .rsync-filter'\n");
 327   rprintf(F,"     --exclude=PATTERN       exclude files matching PATTERN\n");
 328   rprintf(F,"     --exclude-from=FILE     read exclude patterns from FILE\n");
 329   rprintf(F,"     --include=PATTERN       don't exclude files matching PATTERN\n");
 330   rprintf(F,"     --include-from=FILE     read include patterns from FILE\n");
 331   rprintf(F,"     --files-from=FILE       read list of source-file names from FILE\n");
 332   rprintf(F," -0, --from0                 all *-from file lists are delimited by nulls\n");
 333   rprintf(F,"     --version               print version number\n");
 334   rprintf(F,"     --port=PORT             specify double-colon alternate port number\n");
 335   rprintf(F,"     --blocking-io           use blocking I/O for the remote shell\n");
 336   rprintf(F,"     --no-blocking-io        turn off blocking I/O when it is the default\n");
 337   rprintf(F,"     --stats                 give some file-transfer stats\n");
 338   rprintf(F,"     --progress              show progress during transfer\n");
 339   rprintf(F," -P                          same as --partial --progress\n");
 340   rprintf(F," -i, --itemize-changes       output a change-summary for all updates\n");
 341   rprintf(F,"     --log-format=FORMAT     log file-transfers using specified format\n");
 342   rprintf(F,"     --password-file=FILE    read password from FILE\n");
 343   rprintf(F,"     --list-only             list the files instead of copying them\n");
 344   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
 345   rprintf(F,"     --write-batch=FILE      write a batched update to FILE\n");
 346   rprintf(F,"     --read-batch=FILE       read a batched update from FILE\n");
 347 #ifdef INET6
 348   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 349   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 350 #endif
 351   rprintf(F," -h, --help                  show this help screen\n");
 352
 353   rprintf(F,"\nUse \"rsync --daemon --help\" to see the daemon-mode command-line options.\n");
 354   rprintf(F,"Please see the rsync(1) and rsyncd.conf(5) man pages for full documentation.\n");
 355   rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
 356 }
 357
 358 enum {OPT_VERSION = 1000, OPT_DAEMON, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
 359       OPT_FILTER, OPT_COMPARE_DEST, OPT_COPY_DEST, OPT_LINK_DEST,
 360       OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
 361       OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_TIMEOUT, OPT_MAX_SIZE,
 362       OPT_REFUSED_BASE = 9000};
 363
 364 static struct poptOption long_options[] = {
 365   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 366   {"version",          0,  POPT_ARG_NONE,   0, OPT_VERSION, 0, 0},
 367   {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
 368   {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path, 0, 0, 0 },
 369   {"password-file",    0,  POPT_ARG_STRING, &password_file, 0, 0, 0 },
 370   {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
 371   {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
 372   {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
 373   {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system, 0, 0, 0 },
 374   {"existing",         0,  POPT_ARG_NONE,   &only_existing, 0, 0, 0 },
 375   {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing, 0, 0, 0 },
 376   {"del",              0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 377   {"delete",           0,  POPT_ARG_NONE,   &delete_mode, 0, 0, 0 },
 378   {"delete-before",    0,  POPT_ARG_VAL,    &delete_before, 2, 0, 0 },
 379   {"delete-during",    0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 380   {"delete-after",     0,  POPT_ARG_NONE,   &delete_after, 0, 0, 0 },
 381   {"delete-excluded",  0,  POPT_ARG_NONE,   &delete_excluded, 0, 0, 0 },
 382   {"remove-sent-files",0,  POPT_ARG_NONE,   &remove_sent_files, 0, 0, 0 },
 383   {"force",            0,  POPT_ARG_NONE,   &force_delete, 0, 0, 0 },
 384   {"numeric-ids",      0,  POPT_ARG_NONE,   &numeric_ids, 0, 0, 0 },
 385   {"filter",          'f', POPT_ARG_STRING, 0, OPT_FILTER, 0, 0 },
 386   {"exclude",          0,  POPT_ARG_STRING, 0, OPT_EXCLUDE, 0, 0 },
 387   {"include",          0,  POPT_ARG_STRING, 0, OPT_INCLUDE, 0, 0 },
 388   {"exclude-from",     0,  POPT_ARG_STRING, 0, OPT_EXCLUDE_FROM, 0, 0 },
 389   {"include-from",     0,  POPT_ARG_STRING, 0, OPT_INCLUDE_FROM, 0, 0 },
 390   {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
 391   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 392   {"backup",          'b', POPT_ARG_NONE,   &make_backups, 0, 0, 0 },
 393   {"dry-run",         'n', POPT_ARG_NONE,   &dry_run, 0, 0, 0 },
 394   {"sparse",          'S', POPT_ARG_NONE,   &sparse_files, 0, 0, 0 },
 395   {"cvs-exclude",     'C', POPT_ARG_NONE,   &cvs_exclude, 0, 0, 0 },
 396   {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
 397   {"inplace",          0,  POPT_ARG_NONE,   &inplace, 0, 0, 0 },
 398   {"dirs",            'd', POPT_ARG_VAL,    &xfer_dirs, 2, 0, 0 },
 399   {"links",           'l', POPT_ARG_NONE,   &preserve_links, 0, 0, 0 },
 400   {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
 401   {"keep-dirlinks",   'K', POPT_ARG_NONE,   &keep_dirlinks, 0, 0, 0 },
 402   {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
 403   {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 404   {"copy-unsafe-links",0,  POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
 405   {"perms",           'p', POPT_ARG_NONE,   &preserve_perms, 0, 0, 0 },
 406   {"owner",           'o', POPT_ARG_NONE,   &preserve_uid, 0, 0, 0 },
 407   {"group",           'g', POPT_ARG_NONE,   &preserve_gid, 0, 0, 0 },
 408   {"devices",         'D', POPT_ARG_NONE,   &preserve_devices, 0, 0, 0 },
 409   {"times",           't', POPT_ARG_NONE,   &preserve_times, 0, 0, 0 },
 410   {"omit-dir-times",  'O', POPT_ARG_NONE,   &omit_dir_times, 0, 0, 0 },
 411   {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
 412   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 413   {"quiet",           'q', POPT_ARG_NONE,   0, 'q', 0, 0 },
 414   {"archive",         'a', POPT_ARG_NONE,   &archive_mode, 0, 0, 0 },
 415   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 416   {"sender",           0,  POPT_ARG_NONE,   0, OPT_SENDER, 0, 0 },
 417   {"recursive",       'r', POPT_ARG_VAL,    &recurse, -1, 0, 0 },
 418   {"list-only",        0,  POPT_ARG_VAL,    &list_only, 2, 0, 0 },
 419   {"relative",        'R', POPT_ARG_VAL,    &relative_paths, 1, 0, 0 },
 420   {"no-relative",      0,  POPT_ARG_VAL,    &relative_paths, 0, 0, 0 },
 421   {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
 422   {"block-size",      'B', POPT_ARG_LONG,   &block_size, 0, 0, 0 },
 423   {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
 424   {"max-size",         0,  POPT_ARG_STRING, &max_size_arg,  OPT_MAX_SIZE, 0, 0 },
 425   {"timeout",          0,  POPT_ARG_INT,    &io_timeout, OPT_TIMEOUT, 0, 0 },
 426   {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
 427   {"compare-dest",     0,  POPT_ARG_STRING, 0, OPT_COMPARE_DEST, 0, 0 },
 428   {"copy-dest",        0,  POPT_ARG_STRING, 0, OPT_COPY_DEST, 0, 0 },
 429   {"link-dest",        0,  POPT_ARG_STRING, 0, OPT_LINK_DEST, 0, 0 },
 430   {"fuzzy",           'y', POPT_ARG_NONE,   &fuzzy_basis, 0, 0, 0 },
 431   /* TODO: Should this take an optional int giving the compression level? */
 432   {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
 433   {"stats",            0,  POPT_ARG_NONE,   &do_stats, 0, 0, 0 },
 434   {"progress",         0,  POPT_ARG_NONE,   &do_progress, 0, 0, 0 },
 435   {"partial",          0,  POPT_ARG_NONE,   &keep_partial, 0, 0, 0 },
 436   {"partial-dir",      0,  POPT_ARG_STRING, &partial_dir, 0, 0, 0 },
 437   {"delay-updates",    0,  POPT_ARG_NONE,   &delay_updates, 0, 0, 0 },
 438   {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors, 0, 0, 0 },
 439   {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
 440   {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
 441   {0,                 'F', POPT_ARG_NONE,   0, 'F', 0, 0 },
 442   {0,                 'P', POPT_ARG_NONE,   0, 'P', 0, 0 },
 443   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 444   {"log-format",       0,  POPT_ARG_STRING, &log_format, 0, 0, 0 },
 445   {"itemize-changes", 'i', POPT_ARG_NONE,   &itemize_changes, 0, 0, 0 },
 446   {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
 447   {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
 448   {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links, 0, 0, 0 },
 449   {"read-batch",       0,  POPT_ARG_STRING, &batch_name, OPT_READ_BATCH, 0, 0 },
 450   {"write-batch",      0,  POPT_ARG_STRING, &batch_name, OPT_WRITE_BATCH, 0, 0 },
 451   {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
 452   {"from0",           '0', POPT_ARG_NONE,   &eol_nulls, 0, 0, 0},
 453   {"no-implied-dirs",  0,  POPT_ARG_VAL,    &implied_dirs, 0, 0, 0 },
 454   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 455   {"checksum-seed",    0,  POPT_ARG_INT,    &checksum_seed, 0, 0, 0 },
 456 #ifdef INET6
 457   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 458   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 459 #endif
 460   /* All these options switch us into daemon-mode option-parsing. */
 461   {"address",          0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
 462   {"config",           0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
 463   {"daemon",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 464   {"detach",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 465   {"no-detach",        0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 466   {0,0,0,0, 0, 0, 0}
 467 };
 468
 469 static void daemon_usage(enum logcode F)
 470 {
 471   print_rsync_version(F);
 472
 473   rprintf(F,"\nUsage: rsync --daemon [OPTION]...\n");
 474   rprintf(F,"     --address=ADDRESS       bind to the specified address\n");
 475   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
 476   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");
 477   rprintf(F,"     --no-detach             do not detach from the parent\n");
 478   rprintf(F,"     --port=PORT             listen on alternate port number\n");
 479   rprintf(F," -v, --verbose               increase verbosity\n");
 480 #ifdef INET6
 481   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 482   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 483 #endif
 484   rprintf(F," -h, --help                  show this help screen\n");
 485
 486   rprintf(F,"\nIf you were not trying to invoke rsync as a daemon, avoid using any of the\n");
 487   rprintf(F,"daemon-specific rsync options.  See also the rsyncd.conf(5) man page.\n");
 488 }
 489
 490 static struct poptOption long_daemon_options[] = {
 491   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 492   {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
 493   {"bwlimit",          0,  POPT_ARG_INT,    &daemon_bwlimit, 0, 0, 0 },
 494   {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
 495   {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
 496 #ifdef INET6
 497   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 498   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 499 #endif
 500   {"detach",           0,  POPT_ARG_VAL,    &no_detach, 0, 0, 0 },
 501   {"no-detach",        0,  POPT_ARG_VAL,    &no_detach, 1, 0, 0 },
 502   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 503   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 504   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 505   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 506   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 507   {0,0,0,0, 0, 0, 0}
 508 };
 509
 510
 511 static char err_buf[200];
 512
 513
 514 /**
 515  * Store the option error message, if any, so that we can log the
 516  * connection attempt (which requires parsing the options), and then
 517  * show the error later on.
 518  **/
 519 void option_error(void)
 520 {
 521         if (!err_buf[0]) {
 522                 strcpy(err_buf, "Error parsing options: "
 523                     "option may be supported on client but not on server?\n");
 524         }
 525
 526         rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
 527 }
 528
 529
 530 /**
 531  * Tweak the option table to disable all options that the rsyncd.conf
 532  * file has told us to refuse.
 533  **/
 534 static void set_refuse_options(char *bp)
 535 {
 536         struct poptOption *op;
 537         char *cp, shortname[2];
 538         int is_wild, found_match;
 539
 540         shortname[1] = '\0';
 541
 542         while (1) {
 543                 while (*bp == ' ') bp++;
 544                 if (!*bp)
 545                         break;
 546                 if ((cp = strchr(bp, ' ')) != NULL)
 547                         *cp= '\0';
 548                 is_wild = strpbrk(bp, "*?[") != NULL;
 549                 found_match = 0;
 550                 for (op = long_options; ; op++) {
 551                         *shortname = op->shortName;
 552                         if (!op->longName && !*shortname)
 553                                 break;
 554                         if ((op->longName && wildmatch(bp, op->longName))
 555                             || (*shortname && wildmatch(bp, shortname))) {
 556                                 if (op->argInfo == POPT_ARG_VAL)
 557                                         op->argInfo = POPT_ARG_NONE;
 558                                 op->val = (op - long_options) + OPT_REFUSED_BASE;
 559                                 found_match = 1;
 560                                 /* These flags are set to let us easily check
 561                                  * an implied option later in the code. */
 562                                 switch (*shortname) {
 563                                 case 'r': case 'd': case 'l': case 'p':
 564                                 case 't': case 'g': case 'o': case 'D':
 565                                         refused_archive_part = op->val;
 566                                         break;
 567                                 case '\0':
 568                                         if (wildmatch("delete", op->longName))
 569                                                 refused_delete = op->val;
 570                                         else if (wildmatch("delete-before", op->longName))
 571                                                 refused_delete_before = op->val;
 572                                         else if (wildmatch("partial", op->longName))
 573                                                 refused_partial = op->val;
 574                                         else if (wildmatch("progress", op->longName))
 575                                                 refused_progress = op->val;
 576                                         break;
 577                                 }
 578                                 if (!is_wild)
 579                                         break;
 580                         }
 581                 }
 582                 if (!found_match) {
 583                         rprintf(FLOG, "No match for refuse-options string \"%s\"\n",
 584                                 bp);
 585                 }
 586                 if (!cp)
 587                         break;
 588                 *cp = ' ';
 589                 bp = cp + 1;
 590         }
 591
 592         for (op = long_options; ; op++) {
 593                 *shortname = op->shortName;
 594                 if (!op->longName && !*shortname)
 595                         break;
 596                 if (op->val == OPT_DAEMON) {
 597                         if (op->argInfo == POPT_ARG_VAL)
 598                                 op->argInfo = POPT_ARG_NONE;
 599                         op->val = (op - long_options) + OPT_REFUSED_BASE;
 600                 }
 601         }
 602 }
 603
 604
 605 static int count_args(const char **argv)
 606 {
 607         int i = 0;
 608
 609         if (argv) {
 610                 while (argv[i] != NULL)
 611                         i++;
 612         }
 613
 614         return i;
 615 }
 616
 617
 618 static void create_refuse_error(int which)
 619 {
 620         /* The "which" value is the index + OPT_REFUSED_BASE. */
 621         struct poptOption *op = &long_options[which - OPT_REFUSED_BASE];
 622         int n = snprintf(err_buf, sizeof err_buf,
 623                          "The server is configured to refuse --%s\n",
 624                          op->longName) - 1;
 625         if (op->shortName) {
 626                 snprintf(err_buf + n, sizeof err_buf - n,
 627                          " (-%c)\n", op->shortName);
 628         }
 629 }
 630
 631
 632 /**
 633  * Process command line arguments.  Called on both local and remote.
 634  *
 635  * @retval 1 if all options are OK; with globals set to appropriate
 636  * values
 637  *
 638  * @retval 0 on error, with err_buf containing an explanation
 639  **/
 640 int parse_arguments(int *argc, const char ***argv, int frommain)
 641 {
 642         int opt;
 643         char *ref = lp_refuse_options(module_id);
 644         const char *arg;
 645         poptContext pc;
 646
 647         if (ref && *ref)
 648                 set_refuse_options(ref);
 649
 650         /* TODO: Call poptReadDefaultConfig; handle errors. */
 651
 652         /* The context leaks in case of an error, but if there's a
 653          * problem we always exit anyhow. */
 654         pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
 655         poptReadDefaultConfig(pc, 0);
 656
 657         while ((opt = poptGetNextOpt(pc)) != -1) {
 658                 /* most options are handled automatically by popt;
 659                  * only special cases are returned and listed here. */
 660
 661                 switch (opt) {
 662                 case OPT_VERSION:
 663                         print_rsync_version(FINFO);
 664                         exit_cleanup(0);
 665
 666                 case OPT_DAEMON:
 667                         if (am_daemon) {
 668                                 strcpy(err_buf, "Attempt to hack rsync thwarted!\n");
 669                                 return 0;
 670                         }
 671                         poptFreeContext(pc);
 672                         pc = poptGetContext(RSYNC_NAME, *argc, *argv,
 673                                             long_daemon_options, 0);
 674                         while ((opt = poptGetNextOpt(pc)) != -1) {
 675                                 switch (opt) {
 676                                 case 'h':
 677                                         daemon_usage(FINFO);
 678                                         exit_cleanup(0);
 679
 680                                 case 'v':
 681                                         verbose++;
 682                                         break;
 683
 684                                 default:
 685                                         rprintf(FERROR,
 686                                             "rsync: %s: %s (in daemon mode)\n",
 687                                             poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 688                                             poptStrerror(opt));
 689                                         goto daemon_error;
 690                                 }
 691                         }
 692                         if (!daemon_opt) {
 693                                 rprintf(FERROR, "Daemon option(s) used without --daemon.\n");
 694                             daemon_error:
 695                                 rprintf(FERROR,
 696                                     "(Type \"rsync --daemon --help\" for assistance with daemon mode.)\n");
 697                                 exit_cleanup(RERR_SYNTAX);
 698                         }
 699                         *argv = poptGetArgs(pc);
 700                         *argc = count_args(*argv);
 701                         daemon_opt = 0;
 702                         am_daemon = 1;
 703                         return 1;
 704
 705                 case OPT_MODIFY_WINDOW:
 706                         /* The value has already been set by popt, but
 707                          * we need to remember that we're using a
 708                          * non-default setting. */
 709                         modify_window_set = 1;
 710                         break;
 711
 712                 case OPT_FILTER:
 713                         parse_rule(&filter_list, poptGetOptArg(pc), 0, 0);
 714                         break;
 715
 716                 case OPT_EXCLUDE:
 717                         parse_rule(&filter_list, poptGetOptArg(pc),
 718                                    0, XFLG_OLD_PREFIXES);
 719                         break;
 720
 721                 case OPT_INCLUDE:
 722                         parse_rule(&filter_list, poptGetOptArg(pc),
 723                                    MATCHFLG_INCLUDE, XFLG_OLD_PREFIXES);
 724                         break;
 725
 726                 case OPT_EXCLUDE_FROM:
 727                 case OPT_INCLUDE_FROM:
 728                         arg = poptGetOptArg(pc);
 729                         if (sanitize_paths)
 730                                 arg = sanitize_path(NULL, arg, NULL, 0);
 731                         if (server_filter_list.head) {
 732                                 char *cp = (char *)arg;
 733                                 if (!*cp)
 734                                         goto options_rejected;
 735                                 clean_fname(cp, 1);
 736                                 if (check_filter(&server_filter_list, cp, 0) < 0)
 737                                         goto options_rejected;
 738                         }
 739                         parse_filter_file(&filter_list, arg,
 740                                 opt == OPT_INCLUDE_FROM ? MATCHFLG_INCLUDE : 0,
 741                                 XFLG_FATAL_ERRORS | XFLG_OLD_PREFIXES);
 742                         break;
 743
 744                 case 'h':
 745                         usage(FINFO);
 746                         exit_cleanup(0);
 747
 748                 case 'v':
 749                         verbose++;
 750                         break;
 751
 752                 case 'q':
 753                         if (frommain)
 754                                 quiet++;
 755                         break;
 756
 757                 case OPT_SENDER:
 758                         if (!am_server) {
 759                                 usage(FERROR);
 760                                 exit_cleanup(RERR_SYNTAX);
 761                         }
 762                         am_sender = 1;
 763                         break;
 764
 765                 case 'F':
 766                         switch (++F_option_cnt) {
 767                         case 1:
 768                                 parse_rule(&filter_list,": /.rsync-filter",0,0);
 769                                 break;
 770                         case 2:
 771                                 parse_rule(&filter_list,"- .rsync-filter",0,0);
 772                                 break;
 773                         }
 774                         break;
 775
 776                 case 'P':
 777                         if (refused_partial || refused_progress) {
 778                                 create_refuse_error(refused_partial
 779                                     ? refused_partial : refused_progress);
 780                                 return 0;
 781                         }
 782                         do_progress = 1;
 783                         keep_partial = 1;
 784                         break;
 785
 786                 case OPT_WRITE_BATCH:
 787                         /* batch_name is already set */
 788                         write_batch = 1;
 789                         break;
 790
 791                 case OPT_READ_BATCH:
 792                         /* batch_name is already set */
 793                         read_batch = 1;
 794                         break;
 795
 796                 case OPT_MAX_SIZE:
 797                         for (arg = max_size_arg; isdigit(*(uchar*)arg); arg++) {}
 798                         if (*arg == '.')
 799                                 for (arg++; isdigit(*(uchar*)arg); arg++) {}
 800                         switch (*arg) {
 801                         case 'k': case 'K':
 802                                 max_size = atof(max_size_arg) * 1024;
 803                                 break;
 804                         case 'm': case 'M':
 805                                 max_size = atof(max_size_arg) * 1024*1024;
 806                                 break;
 807                         case 'g': case 'G':
 808                                 max_size = atof(max_size_arg) * 1024*1024*1024;
 809                                 break;
 810                         case '\0':
 811                                 max_size = atof(max_size_arg);
 812                                 break;
 813                         default:
 814                                 max_size = 0;
 815                                 break;
 816                         }
 817                         if (max_size <= 0) {
 818                                 snprintf(err_buf, sizeof err_buf,
 819                                         "--max-size value is invalid: %s\n",
 820                                         max_size_arg);
 821                                 return 0;
 822                         }
 823                         break;
 824
 825                 case OPT_TIMEOUT:
 826                         if (io_timeout && io_timeout < select_timeout)
 827                                 select_timeout = io_timeout;
 828                         break;
 829
 830                 case OPT_LINK_DEST:
 831 #ifdef HAVE_LINK
 832                         link_dest = 1;
 833                         dest_option = "--link-dest";
 834                         goto set_dest_dir;
 835 #else
 836                         snprintf(err_buf, sizeof err_buf,
 837                                  "hard links are not supported on this %s\n",
 838                                  am_server ? "server" : "client");
 839                         return 0;
 840 #endif
 841
 842                 case OPT_COPY_DEST:
 843                         copy_dest = 1;
 844                         dest_option = "--copy-dest";
 845                         goto set_dest_dir;
 846
 847                 case OPT_COMPARE_DEST:
 848                         compare_dest = 1;
 849                         dest_option = "--compare-dest";
 850                 set_dest_dir:
 851                         if (basis_dir_cnt >= MAX_BASIS_DIRS) {
 852                                 snprintf(err_buf, sizeof err_buf,
 853                                         "ERROR: at most %d %s args may be specified\n",
 854                                         MAX_BASIS_DIRS, dest_option);
 855                                 return 0;
 856                         }
 857                         arg = poptGetOptArg(pc);
 858                         if (sanitize_paths)
 859                                 arg = sanitize_path(NULL, arg, NULL, 0);
 860                         basis_dir[basis_dir_cnt++] = (char *)arg;
 861                         break;
 862
 863                 default:
 864                         /* A large opt value means that set_refuse_options()
 865                          * turned this option off. */
 866                         if (opt >= OPT_REFUSED_BASE) {
 867                                 create_refuse_error(opt);
 868                                 return 0;
 869                         }
 870                         snprintf(err_buf, sizeof err_buf, "%s%s: %s\n",
 871                                  am_server ? "on remote machine: " : "",
 872                                  poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 873                                  poptStrerror(opt));
 874                         return 0;
 875                 }
 876         }
 877
 878         if (am_sender < 0)
 879                 am_sender = 0;
 880
 881 #ifndef SUPPORT_LINKS
 882         if (preserve_links && !am_sender) {
 883                 snprintf(err_buf, sizeof err_buf,
 884                          "symlinks are not supported on this %s\n",
 885                          am_server ? "server" : "client");
 886                 return 0;
 887         }
 888 #endif
 889
 890 #ifndef SUPPORT_HARD_LINKS
 891         if (preserve_hard_links) {
 892                 snprintf(err_buf, sizeof err_buf,
 893                          "hard links are not supported on this %s\n",
 894                          am_server ? "server" : "client");
 895                 return 0;
 896         }
 897 #endif
 898
 899         if (write_batch && read_batch) {
 900                 snprintf(err_buf, sizeof err_buf,
 901                         "--write-batch and --read-batch can not be used together\n");
 902                 return 0;
 903         }
 904         if (write_batch || read_batch) {
 905                 if (dry_run) {
 906                         snprintf(err_buf, sizeof err_buf,
 907                                 "--%s-batch cannot be used with --dry_run (-n)\n",
 908                                 write_batch ? "write" : "read");
 909                         return 0;
 910                 }
 911                 if (am_server) {
 912                         rprintf(FINFO,
 913                                 "ignoring --%s-batch option sent to server\n",
 914                                 write_batch ? "write" : "read");
 915                         /* We don't actually exit_cleanup(), so that we can
 916                          * still service older version clients that still send
 917                          * batch args to server. */
 918                         read_batch = write_batch = 0;
 919                         batch_name = NULL;
 920                 }
 921         }
 922         if (read_batch && files_from) {
 923                 snprintf(err_buf, sizeof err_buf,
 924                         "--read-batch cannot be used with --files-from\n");
 925                 return 0;
 926         }
 927         if (batch_name && strlen(batch_name) > MAX_BATCH_NAME_LEN) {
 928                 snprintf(err_buf, sizeof err_buf,
 929                         "the batch-file name must be %d characters or less.\n",
 930                         MAX_BATCH_NAME_LEN);
 931                 return 0;
 932         }
 933
 934         if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
 935                 snprintf(err_buf, sizeof err_buf,
 936                          "the --temp-dir path is WAY too long.\n");
 937                 return 0;
 938         }
 939
 940         if (compare_dest + copy_dest + link_dest > 1) {
 941                 snprintf(err_buf, sizeof err_buf,
 942                         "You may not mix --compare-dest, --copy-dest, and --link-dest.\n");
 943                 return 0;
 944         }
 945
 946         if (archive_mode) {
 947                 if (refused_archive_part) {
 948                         create_refuse_error(refused_archive_part);
 949                         return 0;
 950                 }
 951                 if (!files_from)
 952                         recurse = -1; /* infinite recursion */
 953 #ifdef SUPPORT_LINKS
 954                 preserve_links = 1;
 955 #endif
 956                 preserve_perms = 1;
 957                 preserve_times = 1;
 958                 preserve_gid = 1;
 959                 preserve_uid = 1;
 960                 preserve_devices = 1;
 961         }
 962
 963         if (recurse || list_only || files_from)
 964                 xfer_dirs |= 1;
 965
 966         if (relative_paths < 0)
 967                 relative_paths = files_from? 1 : 0;
 968
 969         if (!!delete_before + delete_during + delete_after > 1) {
 970                 snprintf(err_buf, sizeof err_buf,
 971                         "You may not combine multiple --delete-WHEN options.\n");
 972                 return 0;
 973         }
 974         if (!recurse) {
 975                 delete_before = delete_during = delete_after = 0;
 976                 delete_mode = delete_excluded = 0;
 977         } else if (delete_before || delete_during || delete_after)
 978                 delete_mode = 1;
 979         else if (delete_mode || delete_excluded) {
 980                 if (refused_delete_before) {
 981                         create_refuse_error(refused_delete_before);
 982                         return 0;
 983                 }
 984                 delete_mode = delete_before = 1;
 985         }
 986
 987         if (delete_mode && refused_delete) {
 988                 create_refuse_error(refused_delete);
 989                 return 0;
 990         }
 991
 992         if (remove_sent_files) {
 993                 /* We only want to infer this refusal of --remove-sent-files
 994                  * via the refusal of "delete", not any of the "delete-FOO"
 995                  * options. */
 996                 if (refused_delete && am_sender) {
 997                         create_refuse_error(refused_delete);
 998                         return 0;
 999                 }
1000                 need_messages_from_generator = 1;
1001         }
1002
1003         *argv = poptGetArgs(pc);
1004         *argc = count_args(*argv);
1005
1006         if (sanitize_paths) {
1007                 int i;
1008                 for (i = *argc; i-- > 0; )
1009                         (*argv)[i] = sanitize_path(NULL, (*argv)[i], "", 0);
1010                 if (tmpdir)
1011                         tmpdir = sanitize_path(NULL, tmpdir, NULL, 0);
1012                 if (partial_dir)
1013                         partial_dir = sanitize_path(NULL, partial_dir, NULL, 0);
1014                 if (backup_dir)
1015                         backup_dir = sanitize_path(NULL, backup_dir, NULL, 0);
1016                 if (files_from)
1017                         files_from = sanitize_path(NULL, files_from, NULL, 0);
1018         }
1019         if (server_filter_list.head && !am_sender) {
1020                 struct filter_list_struct *elp = &server_filter_list;
1021                 int i;
1022                 if (tmpdir) {
1023                         if (!*tmpdir)
1024                                 goto options_rejected;
1025                         clean_fname(tmpdir, 1);
1026                         if (check_filter(elp, tmpdir, 1) < 0)
1027                                 goto options_rejected;
1028                 }
1029                 if (partial_dir && *partial_dir) {
1030                         clean_fname(partial_dir, 1);
1031                         if (check_filter(elp, partial_dir, 1) < 0)
1032                                 goto options_rejected;
1033                 }
1034                 for (i = 0; i < basis_dir_cnt; i++) {
1035                         if (!*basis_dir[i])
1036                                 goto options_rejected;
1037                         clean_fname(basis_dir[i], 1);
1038                         if (check_filter(elp, basis_dir[i], 1) < 0)
1039                                 goto options_rejected;
1040                 }
1041                 if (backup_dir) {
1042                         if (!*backup_dir)
1043                                 goto options_rejected;
1044                         clean_fname(backup_dir, 1);
1045                         if (check_filter(elp, backup_dir, 1) < 0)
1046                                 goto options_rejected;
1047                 }
1048         }
1049         if (server_filter_list.head && files_from) {
1050                 if (!*files_from)
1051                         goto options_rejected;
1052                 clean_fname(files_from, 1);
1053                 if (check_filter(&server_filter_list, files_from, 0) < 0) {
1054                     options_rejected:
1055                         snprintf(err_buf, sizeof err_buf,
1056                             "Your options have been rejected by the server.\n");
1057                         return 0;
1058                 }
1059         }
1060
1061         if (!backup_suffix)
1062                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
1063         backup_suffix_len = strlen(backup_suffix);
1064         if (strchr(backup_suffix, '/') != NULL) {
1065                 snprintf(err_buf, sizeof err_buf,
1066                         "--suffix cannot contain slashes: %s\n",
1067                         backup_suffix);
1068                 return 0;
1069         }
1070         if (backup_dir) {
1071                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
1072                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
1073                 if (backup_dir_remainder < 32) {
1074                         snprintf(err_buf, sizeof err_buf,
1075                                 "the --backup-dir path is WAY too long.\n");
1076                         return 0;
1077                 }
1078                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
1079                         backup_dir_buf[backup_dir_len++] = '/';
1080                         backup_dir_buf[backup_dir_len] = '\0';
1081                 }
1082                 if (verbose > 1 && !am_sender) {
1083                         rprintf(FINFO, "backup_dir is %s\n",
1084                                 safe_fname(backup_dir_buf));
1085                 }
1086         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
1087                 snprintf(err_buf, sizeof err_buf,
1088                         "--suffix cannot be a null string without --backup-dir\n");
1089                 return 0;
1090         }
1091
1092         if (log_format) {
1093                 if (strstr(log_format, "%i") != NULL)
1094                         log_format_has_i = 1;
1095                 if (strstr(log_format, "%b") == NULL
1096                  && strstr(log_format, "%c") == NULL)
1097                         log_before_transfer = !am_server;
1098         } else if (itemize_changes) {
1099                 log_format = "%i %n%L";
1100                 log_format_has_i = 1;
1101                 log_before_transfer = !am_server;
1102         }
1103
1104         if ((do_progress || dry_run) && !verbose && !log_before_transfer
1105             && !am_server)
1106                 verbose = 1;
1107
1108         if (verbose && !log_format) {
1109                 log_format = "%n%L";
1110                 log_before_transfer = !am_server;
1111         }
1112         if (log_format_has_i
1113             || (log_format && strstr(log_format, "%o") != NULL))
1114                 log_format_has_o_or_i = 1;
1115
1116         if (daemon_bwlimit && (!bwlimit || bwlimit > daemon_bwlimit))
1117                 bwlimit = daemon_bwlimit;
1118         if (bwlimit) {
1119                 bwlimit_writemax = (size_t)bwlimit * 128;
1120                 if (bwlimit_writemax < 512)
1121                         bwlimit_writemax = 512;
1122         }
1123
1124         if (delay_updates && !partial_dir)
1125                 partial_dir = partialdir_for_delayupdate;
1126
1127         if (inplace) {
1128 #ifdef HAVE_FTRUNCATE
1129                 if (partial_dir) {
1130                         snprintf(err_buf, sizeof err_buf,
1131                                  "--inplace cannot be used with --%s\n",
1132                                  delay_updates ? "delay-updates" : "partial-dir");
1133                         return 0;
1134                 }
1135                 /* --inplace implies --partial for refusal purposes, but we
1136                  * clear the keep_partial flag for internal logic purposes. */
1137                 if (refused_partial) {
1138                         create_refuse_error(refused_partial);
1139                         return 0;
1140                 }
1141                 keep_partial = 0;
1142 #else
1143                 snprintf(err_buf, sizeof err_buf,
1144                          "--inplace is not supported on this %s\n",
1145                          am_server ? "server" : "client");
1146                 return 0;
1147 #endif
1148         } else {
1149                 if (keep_partial && !partial_dir) {
1150                         if ((arg = getenv("RSYNC_PARTIAL_DIR")) != NULL && *arg)
1151                                 partial_dir = strdup(arg);
1152                 }
1153                 if (partial_dir) {
1154                         if (*partial_dir)
1155                                 clean_fname(partial_dir, 1);
1156                         if (!*partial_dir || strcmp(partial_dir, ".") == 0)
1157                                 partial_dir = NULL;
1158                         else if (*partial_dir != '/') {
1159                                 parse_rule(&filter_list, partial_dir,
1160                                     MATCHFLG_NO_PREFIXES|MATCHFLG_DIRECTORY, 0);
1161                         }
1162                         if (!partial_dir && refused_partial) {
1163                                 create_refuse_error(refused_partial);
1164                                 return 0;
1165                         }
1166                         keep_partial = 1;
1167                 }
1168         }
1169
1170         if (files_from) {
1171                 char *colon;
1172                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
1173                         usage(FERROR);
1174                         exit_cleanup(RERR_SYNTAX);
1175                 }
1176                 if (strcmp(files_from, "-") == 0) {
1177                         filesfrom_fd = 0;
1178                         if (am_server)
1179                                 remote_filesfrom_file = "-";
1180                 }
1181                 else if ((colon = find_colon(files_from)) != 0) {
1182                         if (am_server) {
1183                                 usage(FERROR);
1184                                 exit_cleanup(RERR_SYNTAX);
1185                         }
1186                         remote_filesfrom_file = colon+1 + (colon[1] == ':');
1187                         if (strcmp(remote_filesfrom_file, "-") == 0) {
1188                                 snprintf(err_buf, sizeof err_buf,
1189                                         "Invalid --files-from remote filename\n");
1190                                 return 0;
1191                         }
1192                 } else {
1193                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
1194                         if (filesfrom_fd < 0) {
1195                                 snprintf(err_buf, sizeof err_buf,
1196                                         "failed to open files-from file %s: %s\n",
1197                                         files_from, strerror(errno));
1198                                 return 0;
1199                         }
1200                 }
1201         }
1202
1203         return 1;
1204 }
1205
1206
1207 /**
1208  * Construct a filtered list of options to pass through from the
1209  * client to the server.
1210  *
1211  * This involves setting options that will tell the server how to
1212  * behave, and also filtering out options that are processed only
1213  * locally.
1214  **/
1215 void server_options(char **args,int *argc)
1216 {
1217         static char argstr[50+MAX_BASIS_DIRS*2];
1218         int ac = *argc;
1219         char *arg;
1220
1221         int i, x;
1222
1223         if (blocking_io == -1)
1224                 blocking_io = 0;
1225
1226         args[ac++] = "--server";
1227
1228         if (daemon_over_rsh) {
1229                 args[ac++] = "--daemon";
1230                 *argc = ac;
1231                 /* if we're passing --daemon, we're done */
1232                 return;
1233         }
1234
1235         if (!am_sender)
1236                 args[ac++] = "--sender";
1237
1238         x = 1;
1239         argstr[0] = '-';
1240         for (i = 0; i < verbose; i++)
1241                 argstr[x++] = 'v';
1242
1243         /* the -q option is intentionally left out */
1244         if (make_backups)
1245                 argstr[x++] = 'b';
1246         if (update_only)
1247                 argstr[x++] = 'u';
1248         if (dry_run)
1249                 argstr[x++] = 'n';
1250         if (preserve_links)
1251                 argstr[x++] = 'l';
1252         if (copy_links)
1253                 argstr[x++] = 'L';
1254         if (xfer_dirs > 1)
1255                 argstr[x++] = 'd';
1256         if (keep_dirlinks && am_sender)
1257                 argstr[x++] = 'K';
1258
1259         if (whole_file > 0)
1260                 argstr[x++] = 'W';
1261         /* We don't need to send --no-whole-file, because it's the
1262          * default for remote transfers, and in any case old versions
1263          * of rsync will not understand it. */
1264
1265         if (preserve_hard_links)
1266                 argstr[x++] = 'H';
1267         if (preserve_uid)
1268                 argstr[x++] = 'o';
1269         if (preserve_gid)
1270                 argstr[x++] = 'g';
1271         if (preserve_devices)
1272                 argstr[x++] = 'D';
1273         if (preserve_times)
1274                 argstr[x++] = 't';
1275         if (omit_dir_times && am_sender)
1276                 argstr[x++] = 'O';
1277         if (preserve_perms)
1278                 argstr[x++] = 'p';
1279         if (recurse < 0)
1280                 argstr[x++] = 'r';
1281         if (always_checksum)
1282                 argstr[x++] = 'c';
1283         if (cvs_exclude)
1284                 argstr[x++] = 'C';
1285         if (ignore_times)
1286                 argstr[x++] = 'I';
1287         if (relative_paths)
1288                 argstr[x++] = 'R';
1289         if (one_file_system)
1290                 argstr[x++] = 'x';
1291         if (sparse_files)
1292                 argstr[x++] = 'S';
1293         if (do_compression)
1294                 argstr[x++] = 'z';
1295
1296         /* This is a complete hack - blame Rusty.  FIXME!
1297          * This hack is only needed for older rsync versions that
1298          * don't understand the --list-only option. */
1299         if (list_only == 1 && recurse >= 0)
1300                 argstr[x++] = 'r';
1301
1302         argstr[x] = 0;
1303
1304         if (x != 1)
1305                 args[ac++] = argstr;
1306
1307         if (list_only > 1)
1308                 args[ac++] = "--list-only";
1309
1310         /* The server side doesn't use our log-format, but in certain
1311          * circumstances they need to know a little about the option. */
1312         if (log_format && am_sender) {
1313                 if (log_format_has_i)
1314                         args[ac++] = "--log-format=%i";
1315                 else if (log_format_has_o_or_i)
1316                         args[ac++] = "--log-format=%o";
1317                 else if (!verbose)
1318                         args[ac++] = "--log-format=X";
1319         }
1320
1321         if (block_size) {
1322                 if (asprintf(&arg, "-B%lu", block_size) < 0)
1323                         goto oom;
1324                 args[ac++] = arg;
1325         }
1326
1327         if (max_delete && am_sender) {
1328                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
1329                         goto oom;
1330                 args[ac++] = arg;
1331         }
1332
1333         if (max_size && am_sender) {
1334                 args[ac++] = "--max-size";
1335                 args[ac++] = max_size_arg;
1336         }
1337
1338         if (io_timeout) {
1339                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
1340                         goto oom;
1341                 args[ac++] = arg;
1342         }
1343
1344         if (bwlimit) {
1345                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
1346                         goto oom;
1347                 args[ac++] = arg;
1348         }
1349
1350         if (backup_dir) {
1351                 args[ac++] = "--backup-dir";
1352                 args[ac++] = backup_dir;
1353         }
1354
1355         /* Only send --suffix if it specifies a non-default value. */
1356         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1357                 /* We use the following syntax to avoid weirdness with '~'. */
1358                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1359                         goto oom;
1360                 args[ac++] = arg;
1361         }
1362
1363         if (am_sender) {
1364                 if (delete_excluded)
1365                         args[ac++] = "--delete-excluded";
1366                 else if (delete_before == 1 || delete_after)
1367                         args[ac++] = "--delete";
1368                 if (delete_before > 1)
1369                         args[ac++] = "--delete-before";
1370                 if (delete_during)
1371                         args[ac++] = "--delete-during";
1372                 if (delete_after)
1373                         args[ac++] = "--delete-after";
1374                 if (force_delete)
1375                         args[ac++] = "--force";
1376         }
1377
1378         if (size_only)
1379                 args[ac++] = "--size-only";
1380
1381         if (modify_window_set) {
1382                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1383                         goto oom;
1384                 args[ac++] = arg;
1385         }
1386
1387         if (checksum_seed) {
1388                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1389                         goto oom;
1390                 args[ac++] = arg;
1391         }
1392
1393         if (partial_dir && am_sender) {
1394                 if (partial_dir != partialdir_for_delayupdate) {
1395                         args[ac++] = "--partial-dir";
1396                         args[ac++] = partial_dir;
1397                 }
1398                 if (delay_updates)
1399                         args[ac++] = "--delay-updates";
1400         } else if (keep_partial)
1401                 args[ac++] = "--partial";
1402
1403         if (ignore_errors)
1404                 args[ac++] = "--ignore-errors";
1405
1406         if (copy_unsafe_links)
1407                 args[ac++] = "--copy-unsafe-links";
1408
1409         if (safe_symlinks)
1410                 args[ac++] = "--safe-links";
1411
1412         if (numeric_ids)
1413                 args[ac++] = "--numeric-ids";
1414
1415         if (only_existing && am_sender)
1416                 args[ac++] = "--existing";
1417
1418         if (opt_ignore_existing && am_sender)
1419                 args[ac++] = "--ignore-existing";
1420
1421         if (inplace)
1422                 args[ac++] = "--inplace";
1423
1424         if (tmpdir) {
1425                 args[ac++] = "--temp-dir";
1426                 args[ac++] = tmpdir;
1427         }
1428
1429         if (basis_dir[0] && am_sender) {
1430                 /* the server only needs this option if it is not the sender,
1431                  *   and it may be an older version that doesn't know this
1432                  *   option, so don't send it if client is the sender.
1433                  */
1434                 int i;
1435                 for (i = 0; i < basis_dir_cnt; i++) {
1436                         args[ac++] = dest_option;
1437                         args[ac++] = basis_dir[i];
1438                 }
1439         }
1440
1441         if (files_from && (!am_sender || remote_filesfrom_file)) {
1442                 if (remote_filesfrom_file) {
1443                         args[ac++] = "--files-from";
1444                         args[ac++] = remote_filesfrom_file;
1445                         if (eol_nulls)
1446                                 args[ac++] = "--from0";
1447                 } else {
1448                         args[ac++] = "--files-from=-";
1449                         args[ac++] = "--from0";
1450                 }
1451                 if (!relative_paths)
1452                         args[ac++] = "--no-relative";
1453         }
1454         if (!implied_dirs && !am_sender)
1455                 args[ac++] = "--no-implied-dirs";
1456
1457         if (fuzzy_basis && am_sender)
1458                 args[ac++] = "--fuzzy";
1459
1460         if (remove_sent_files)
1461                 args[ac++] = "--remove-sent-files";
1462
1463         *argc = ac;
1464         return;
1465
1466     oom:
1467         out_of_memory("server_options");
1468 }
1469
1470 /**
1471  * Return the position of a ':' IF it is not part of a filename (i.e. as
1472  * long as it doesn't occur after a slash.
1473  */
1474 char *find_colon(char *s)
1475 {
1476         char *p, *p2;
1477
1478         p = strchr(s,':');
1479         if (!p)
1480                 return NULL;
1481
1482         /* now check to see if there is a / in the string before the : - if there is then
1483            discard the colon on the assumption that the : is part of a filename */
1484         p2 = strchr(s,'/');
1485         if (p2 && p2 < p)
1486                 return NULL;
1487
1488         return p;
1489 }