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