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