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_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 'r': case 'd': case 'l': case 'p':
 552                                 case 't': case 'g': case 'o': case 'D':
 553                                         refused_archive_part = op->val;
 554                                         break;
 555                                 case '\0':
 556                                         if (wildmatch("delete", op->longName))
 557                                                 refused_delete = op->val;
 558                                         else if (wildmatch("delete-before", op->longName))
 559                                                 refused_delete_before = op->val;
 560                                         else if (wildmatch("partial", op->longName))
 561                                                 refused_partial = op->val;
 562                                         else if (wildmatch("progress", op->longName))
 563                                                 refused_progress = op->val;
 564                                         break;
 565                                 }
 566                                 if (!is_wild)
 567                                         break;
 568                         }
 569                 }
 570                 if (!found_match) {
 571                         rprintf(FLOG, "No match for refuse-options string \"%s\"\n",
 572                                 bp);
 573                 }
 574                 if (!cp)
 575                         break;
 576                 *cp = ' ';
 577                 bp = cp + 1;
 578         }
 579 }
 580
 581
 582 static int count_args(const char **argv)
 583 {
 584         int i = 0;
 585
 586         if (argv) {
 587                 while (argv[i] != NULL)
 588                         i++;
 589         }
 590
 591         return i;
 592 }
 593
 594
 595 static void create_refuse_error(int which)
 596 {
 597         /* The "which" value is the index + OPT_REFUSED_BASE. */
 598         struct poptOption *op = &long_options[which - OPT_REFUSED_BASE];
 599         int n = snprintf(err_buf, sizeof err_buf,
 600                          "The server is configured to refuse --%s\n",
 601                          op->longName) - 1;
 602         if (op->shortName) {
 603                 snprintf(err_buf + n, sizeof err_buf - n,
 604                          " (-%c)\n", op->shortName);
 605         }
 606 }
 607
 608
 609 /**
 610  * Process command line arguments.  Called on both local and remote.
 611  *
 612  * @retval 1 if all options are OK; with globals set to appropriate
 613  * values
 614  *
 615  * @retval 0 on error, with err_buf containing an explanation
 616  **/
 617 int parse_arguments(int *argc, const char ***argv, int frommain)
 618 {
 619         int opt;
 620         char *ref = lp_refuse_options(module_id);
 621         const char *arg;
 622         poptContext pc;
 623
 624         if (ref && *ref)
 625                 set_refuse_options(ref);
 626
 627         /* TODO: Call poptReadDefaultConfig; handle errors. */
 628
 629         /* The context leaks in case of an error, but if there's a
 630          * problem we always exit anyhow. */
 631         pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
 632         poptReadDefaultConfig(pc, 0);
 633
 634         while ((opt = poptGetNextOpt(pc)) != -1) {
 635                 /* most options are handled automatically by popt;
 636                  * only special cases are returned and listed here. */
 637
 638                 switch (opt) {
 639                 case OPT_VERSION:
 640                         print_rsync_version(FINFO);
 641                         exit_cleanup(0);
 642
 643                 case OPT_DAEMON:
 644                         if (am_daemon) {
 645                                 strcpy(err_buf, "Attempt to hack rsync thwarted!\n");
 646                                 return 0;
 647                         }
 648                         poptFreeContext(pc);
 649                         pc = poptGetContext(RSYNC_NAME, *argc, *argv,
 650                                             long_daemon_options, 0);
 651                         while ((opt = poptGetNextOpt(pc)) != -1) {
 652                                 switch (opt) {
 653                                 case 'h':
 654                                         daemon_usage(FINFO);
 655                                         exit_cleanup(0);
 656
 657                                 case 'v':
 658                                         verbose++;
 659                                         break;
 660
 661                                 default:
 662                                         rprintf(FERROR,
 663                                             "rsync: %s: %s (in daemon mode)\n",
 664                                             poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 665                                             poptStrerror(opt));
 666                                         goto daemon_error;
 667                                 }
 668                         }
 669                         if (!daemon_opt) {
 670                                 rprintf(FERROR, "Daemon option(s) used without --daemon.\n");
 671                             daemon_error:
 672                                 rprintf(FERROR,
 673                                     "(Type \"rsync --daemon --help\" for assistance with daemon mode.)\n");
 674                                 exit_cleanup(RERR_SYNTAX);
 675                         }
 676                         *argv = poptGetArgs(pc);
 677                         *argc = count_args(*argv);
 678                         daemon_opt = 0;
 679                         am_daemon = 1;
 680                         return 1;
 681
 682                 case OPT_MODIFY_WINDOW:
 683                         /* The value has already been set by popt, but
 684                          * we need to remember that we're using a
 685                          * non-default setting. */
 686                         modify_window_set = 1;
 687                         break;
 688
 689                 case OPT_FILTER:
 690                         parse_rule(&filter_list, poptGetOptArg(pc), 0, 0);
 691                         break;
 692
 693                 case OPT_EXCLUDE:
 694                         parse_rule(&filter_list, poptGetOptArg(pc),
 695                                    0, XFLG_OLD_PREFIXES);
 696                         break;
 697
 698                 case OPT_INCLUDE:
 699                         parse_rule(&filter_list, poptGetOptArg(pc),
 700                                    MATCHFLG_INCLUDE, XFLG_OLD_PREFIXES);
 701                         break;
 702
 703                 case OPT_EXCLUDE_FROM:
 704                 case OPT_INCLUDE_FROM:
 705                         arg = poptGetOptArg(pc);
 706                         if (sanitize_paths)
 707                                 arg = sanitize_path(NULL, arg, NULL, 0);
 708                         if (server_filter_list.head) {
 709                                 char *cp = (char *)arg;
 710                                 if (!*cp)
 711                                         goto options_rejected;
 712                                 clean_fname(cp, 1);
 713                                 if (check_filter(&server_filter_list, cp, 0) < 0)
 714                                         goto options_rejected;
 715                         }
 716                         parse_filter_file(&filter_list, arg,
 717                                 opt == OPT_INCLUDE_FROM ? MATCHFLG_INCLUDE : 0,
 718                                 XFLG_FATAL_ERRORS | XFLG_OLD_PREFIXES);
 719                         break;
 720
 721                 case 'h':
 722                         usage(FINFO);
 723                         exit_cleanup(0);
 724
 725                 case 'v':
 726                         verbose++;
 727                         break;
 728
 729                 case 'q':
 730                         if (frommain)
 731                                 quiet++;
 732                         break;
 733
 734                 case OPT_SENDER:
 735                         if (!am_server) {
 736                                 usage(FERROR);
 737                                 exit_cleanup(RERR_SYNTAX);
 738                         }
 739                         am_sender = 1;
 740                         break;
 741
 742                 case 'F':
 743                         switch (++F_option_cnt) {
 744                         case 1:
 745                                 parse_rule(&filter_list,": /.rsync-filter",0,0);
 746                                 break;
 747                         case 2:
 748                                 parse_rule(&filter_list,"- .rsync-filter",0,0);
 749                                 break;
 750                         }
 751                         break;
 752
 753                 case 'P':
 754                         if (refused_partial || refused_progress) {
 755                                 create_refuse_error(refused_partial
 756                                     ? refused_partial : refused_progress);
 757                                 return 0;
 758                         }
 759                         do_progress = 1;
 760                         keep_partial = 1;
 761                         break;
 762
 763                 case OPT_WRITE_BATCH:
 764                         /* batch_name is already set */
 765                         write_batch = 1;
 766                         break;
 767
 768                 case OPT_READ_BATCH:
 769                         /* batch_name is already set */
 770                         read_batch = 1;
 771                         break;
 772
 773                 case OPT_MAX_SIZE:
 774                         for (arg = max_size_arg; isdigit(*(uchar*)arg); arg++) {}
 775                         if (*arg == '.')
 776                                 for (arg++; isdigit(*(uchar*)arg); arg++) {}
 777                         switch (*arg) {
 778                         case 'k': case 'K':
 779                                 max_size = atof(max_size_arg) * 1024;
 780                                 break;
 781                         case 'm': case 'M':
 782                                 max_size = atof(max_size_arg) * 1024*1024;
 783                                 break;
 784                         case 'g': case 'G':
 785                                 max_size = atof(max_size_arg) * 1024*1024*1024;
 786                                 break;
 787                         case '\0':
 788                                 max_size = atof(max_size_arg);
 789                                 break;
 790                         default:
 791                                 max_size = 0;
 792                                 break;
 793                         }
 794                         if (max_size <= 0) {
 795                                 snprintf(err_buf, sizeof err_buf,
 796                                         "--max-size value is invalid: %s\n",
 797                                         max_size_arg);
 798                                 return 0;
 799                         }
 800                         break;
 801
 802                 case OPT_TIMEOUT:
 803                         if (io_timeout && io_timeout < select_timeout)
 804                                 select_timeout = io_timeout;
 805                         break;
 806
 807                 case OPT_LINK_DEST:
 808 #ifdef HAVE_LINK
 809                         link_dest = 1;
 810                         dest_option = "--link-dest";
 811                         goto set_dest_dir;
 812 #else
 813                         snprintf(err_buf, sizeof err_buf,
 814                                  "hard links are not supported on this %s\n",
 815                                  am_server ? "server" : "client");
 816                         return 0;
 817 #endif
 818
 819                 case OPT_COPY_DEST:
 820                         copy_dest = 1;
 821                         dest_option = "--copy-dest";
 822                         goto set_dest_dir;
 823
 824                 case OPT_COMPARE_DEST:
 825                         compare_dest = 1;
 826                         dest_option = "--compare-dest";
 827                 set_dest_dir:
 828                         if (basis_dir_cnt >= MAX_BASIS_DIRS) {
 829                                 snprintf(err_buf, sizeof err_buf,
 830                                         "ERROR: at most %d %s args may be specified\n",
 831                                         MAX_BASIS_DIRS, dest_option);
 832                                 return 0;
 833                         }
 834                         arg = poptGetOptArg(pc);
 835                         if (sanitize_paths)
 836                                 arg = sanitize_path(NULL, arg, NULL, 0);
 837                         basis_dir[basis_dir_cnt++] = (char *)arg;
 838                         break;
 839
 840                 default:
 841                         /* A large opt value means that set_refuse_options()
 842                          * turned this option off. */
 843                         if (opt >= OPT_REFUSED_BASE) {
 844                                 create_refuse_error(opt);
 845                                 return 0;
 846                         }
 847                         snprintf(err_buf, sizeof err_buf, "%s%s: %s\n",
 848                                  am_server ? "on remote machine: " : "",
 849                                  poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 850                                  poptStrerror(opt));
 851                         return 0;
 852                 }
 853         }
 854
 855         if (am_sender < 0)
 856                 am_sender = 0;
 857
 858 #ifndef SUPPORT_LINKS
 859         if (preserve_links && !am_sender) {
 860                 snprintf(err_buf, sizeof err_buf,
 861                          "symlinks are not supported on this %s\n",
 862                          am_server ? "server" : "client");
 863                 return 0;
 864         }
 865 #endif
 866
 867 #ifndef SUPPORT_HARD_LINKS
 868         if (preserve_hard_links) {
 869                 snprintf(err_buf, sizeof err_buf,
 870                          "hard links are not supported on this %s\n",
 871                          am_server ? "server" : "client");
 872                 return 0;
 873         }
 874 #endif
 875
 876         if (write_batch && read_batch) {
 877                 snprintf(err_buf, sizeof err_buf,
 878                         "--write-batch and --read-batch can not be used together\n");
 879                 return 0;
 880         }
 881         if (write_batch || read_batch) {
 882                 if (dry_run) {
 883                         snprintf(err_buf, sizeof err_buf,
 884                                 "--%s-batch cannot be used with --dry_run (-n)\n",
 885                                 write_batch ? "write" : "read");
 886                         return 0;
 887                 }
 888                 if (am_server) {
 889                         rprintf(FINFO,
 890                                 "ignoring --%s-batch option sent to server\n",
 891                                 write_batch ? "write" : "read");
 892                         /* We don't actually exit_cleanup(), so that we can
 893                          * still service older version clients that still send
 894                          * batch args to server. */
 895                         read_batch = write_batch = 0;
 896                         batch_name = NULL;
 897                 }
 898         }
 899         if (read_batch && files_from) {
 900                 snprintf(err_buf, sizeof err_buf,
 901                         "--read-batch cannot be used with --files-from\n");
 902                 return 0;
 903         }
 904         if (batch_name && strlen(batch_name) > MAX_BATCH_NAME_LEN) {
 905                 snprintf(err_buf, sizeof err_buf,
 906                         "the batch-file name must be %d characters or less.\n",
 907                         MAX_BATCH_NAME_LEN);
 908                 return 0;
 909         }
 910
 911         if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
 912                 snprintf(err_buf, sizeof err_buf,
 913                          "the --temp-dir path is WAY too long.\n");
 914                 return 0;
 915         }
 916
 917         if (compare_dest + copy_dest + link_dest > 1) {
 918                 snprintf(err_buf, sizeof err_buf,
 919                         "You may not mix --compare-dest, --copy-dest, and --link-dest.\n");
 920                 return 0;
 921         }
 922
 923         if (archive_mode) {
 924                 if (refused_archive_part) {
 925                         create_refuse_error(refused_archive_part);
 926                         return 0;
 927                 }
 928                 if (!files_from)
 929                         recurse = -1; /* infinite recursion */
 930 #ifdef SUPPORT_LINKS
 931                 preserve_links = 1;
 932 #endif
 933                 preserve_perms = 1;
 934                 preserve_times = 1;
 935                 preserve_gid = 1;
 936                 preserve_uid = 1;
 937                 preserve_devices = 1;
 938         }
 939
 940         if (recurse || list_only || files_from)
 941                 xfer_dirs |= 1;
 942
 943         if (relative_paths < 0)
 944                 relative_paths = files_from? 1 : 0;
 945
 946         if (!!delete_before + delete_during + delete_after > 1) {
 947                 snprintf(err_buf, sizeof err_buf,
 948                         "You may not combine multiple --delete-WHEN options.\n");
 949                 return 0;
 950         }
 951         if (!recurse) {
 952                 delete_before = delete_during = delete_after = 0;
 953                 delete_mode = delete_excluded = 0;
 954         } else if (delete_before || delete_during || delete_after)
 955                 delete_mode = 1;
 956         else if (delete_mode || delete_excluded) {
 957                 if (refused_delete_before) {
 958                         create_refuse_error(refused_delete_before);
 959                         return 0;
 960                 }
 961                 delete_mode = delete_before = 1;
 962         }
 963
 964         if (delete_mode && refused_delete) {
 965                 create_refuse_error(refused_delete);
 966                 return 0;
 967         }
 968
 969         *argv = poptGetArgs(pc);
 970         *argc = count_args(*argv);
 971
 972         if (sanitize_paths) {
 973                 int i;
 974                 for (i = *argc; i-- > 0; )
 975                         (*argv)[i] = sanitize_path(NULL, (*argv)[i], "", 0);
 976                 if (tmpdir)
 977                         tmpdir = sanitize_path(NULL, tmpdir, NULL, 0);
 978                 if (partial_dir)
 979                         partial_dir = sanitize_path(NULL, partial_dir, NULL, 0);
 980                 if (backup_dir)
 981                         backup_dir = sanitize_path(NULL, backup_dir, NULL, 0);
 982                 if (files_from)
 983                         files_from = sanitize_path(NULL, files_from, NULL, 0);
 984         }
 985         if (server_filter_list.head && !am_sender) {
 986                 struct filter_list_struct *elp = &server_filter_list;
 987                 int i;
 988                 if (tmpdir) {
 989                         if (!*tmpdir)
 990                                 goto options_rejected;
 991                         clean_fname(tmpdir, 1);
 992                         if (check_filter(elp, tmpdir, 1) < 0)
 993                                 goto options_rejected;
 994                 }
 995                 if (partial_dir && *partial_dir) {
 996                         clean_fname(partial_dir, 1);
 997                         if (check_filter(elp, partial_dir, 1) < 0)
 998                                 goto options_rejected;
 999                 }
1000                 for (i = 0; i < basis_dir_cnt; i++) {
1001                         if (!*basis_dir[i])
1002                                 goto options_rejected;
1003                         clean_fname(basis_dir[i], 1);
1004                         if (check_filter(elp, basis_dir[i], 1) < 0)
1005                                 goto options_rejected;
1006                 }
1007                 if (backup_dir) {
1008                         if (!*backup_dir)
1009                                 goto options_rejected;
1010                         clean_fname(backup_dir, 1);
1011                         if (check_filter(elp, backup_dir, 1) < 0)
1012                                 goto options_rejected;
1013                 }
1014         }
1015         if (server_filter_list.head && files_from) {
1016                 if (!*files_from)
1017                         goto options_rejected;
1018                 clean_fname(files_from, 1);
1019                 if (check_filter(&server_filter_list, files_from, 0) < 0) {
1020                     options_rejected:
1021                         snprintf(err_buf, sizeof err_buf,
1022                             "Your options have been rejected by the server.\n");
1023                         return 0;
1024                 }
1025         }
1026
1027         if (!backup_suffix)
1028                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
1029         backup_suffix_len = strlen(backup_suffix);
1030         if (strchr(backup_suffix, '/') != NULL) {
1031                 snprintf(err_buf, sizeof err_buf,
1032                         "--suffix cannot contain slashes: %s\n",
1033                         backup_suffix);
1034                 return 0;
1035         }
1036         if (backup_dir) {
1037                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
1038                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
1039                 if (backup_dir_remainder < 32) {
1040                         snprintf(err_buf, sizeof err_buf,
1041                                 "the --backup-dir path is WAY too long.\n");
1042                         return 0;
1043                 }
1044                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
1045                         backup_dir_buf[backup_dir_len++] = '/';
1046                         backup_dir_buf[backup_dir_len] = '\0';
1047                 }
1048                 if (verbose > 1 && !am_sender) {
1049                         rprintf(FINFO, "backup_dir is %s\n",
1050                                 safe_fname(backup_dir_buf));
1051                 }
1052         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
1053                 snprintf(err_buf, sizeof err_buf,
1054                         "--suffix cannot be a null string without --backup-dir\n");
1055                 return 0;
1056         }
1057
1058         if (log_format) {
1059                 if (strstr(log_format, "%i") != NULL)
1060                         itemize_changes = 1;
1061                 if (strstr(log_format, "%b") == NULL
1062                  && strstr(log_format, "%c") == NULL)
1063                         log_before_transfer = !am_server;
1064         } else if (itemize_changes) {
1065                 log_format = "%i %n%L";
1066                 log_before_transfer = !am_server;
1067         }
1068
1069         if ((do_progress || dry_run) && !verbose && !log_before_transfer
1070             && !am_server)
1071                 verbose = 1;
1072
1073         if (verbose && !log_format) {
1074                 log_format = "%n%L";
1075                 log_before_transfer = !am_server;
1076         }
1077
1078         if (daemon_bwlimit && (!bwlimit || bwlimit > daemon_bwlimit))
1079                 bwlimit = daemon_bwlimit;
1080         if (bwlimit) {
1081                 bwlimit_writemax = (size_t)bwlimit * 128;
1082                 if (bwlimit_writemax < 512)
1083                         bwlimit_writemax = 512;
1084         }
1085
1086         if (delay_updates && !partial_dir)
1087                 partial_dir = partialdir_for_delayupdate;
1088
1089         if (inplace) {
1090 #ifdef HAVE_FTRUNCATE
1091                 if (partial_dir) {
1092                         snprintf(err_buf, sizeof err_buf,
1093                                  "--inplace cannot be used with --%s\n",
1094                                  delay_updates ? "delay-updates" : "partial-dir");
1095                         return 0;
1096                 }
1097                 /* --inplace implies --partial for refusal purposes, but we
1098                  * clear the keep_partial flag for internal logic purposes. */
1099                 if (refused_partial) {
1100                         create_refuse_error(refused_partial);
1101                         return 0;
1102                 }
1103                 keep_partial = 0;
1104 #else
1105                 snprintf(err_buf, sizeof err_buf,
1106                          "--inplace is not supported on this %s\n",
1107                          am_server ? "server" : "client");
1108                 return 0;
1109 #endif
1110         } else {
1111                 if (keep_partial && !partial_dir) {
1112                         if ((arg = getenv("RSYNC_PARTIAL_DIR")) != NULL && *arg)
1113                                 partial_dir = strdup(arg);
1114                 }
1115                 if (partial_dir) {
1116                         if (*partial_dir)
1117                                 clean_fname(partial_dir, 1);
1118                         if (!*partial_dir || strcmp(partial_dir, ".") == 0)
1119                                 partial_dir = NULL;
1120                         else if (*partial_dir != '/') {
1121                                 parse_rule(&filter_list, partial_dir,
1122                                     MATCHFLG_NO_PREFIXES|MATCHFLG_DIRECTORY, 0);
1123                         }
1124                         if (!partial_dir && refused_partial) {
1125                                 create_refuse_error(refused_partial);
1126                                 return 0;
1127                         }
1128                         keep_partial = 1;
1129                 }
1130         }
1131
1132         if (files_from) {
1133                 char *colon;
1134                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
1135                         usage(FERROR);
1136                         exit_cleanup(RERR_SYNTAX);
1137                 }
1138                 if (strcmp(files_from, "-") == 0) {
1139                         filesfrom_fd = 0;
1140                         if (am_server)
1141                                 remote_filesfrom_file = "-";
1142                 }
1143                 else if ((colon = find_colon(files_from)) != 0) {
1144                         if (am_server) {
1145                                 usage(FERROR);
1146                                 exit_cleanup(RERR_SYNTAX);
1147                         }
1148                         remote_filesfrom_file = colon+1 + (colon[1] == ':');
1149                         if (strcmp(remote_filesfrom_file, "-") == 0) {
1150                                 snprintf(err_buf, sizeof err_buf,
1151                                         "Invalid --files-from remote filename\n");
1152                                 return 0;
1153                         }
1154                 } else {
1155                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
1156                         if (filesfrom_fd < 0) {
1157                                 snprintf(err_buf, sizeof err_buf,
1158                                         "failed to open files-from file %s: %s\n",
1159                                         files_from, strerror(errno));
1160                                 return 0;
1161                         }
1162                 }
1163         }
1164
1165         return 1;
1166 }
1167
1168
1169 /**
1170  * Construct a filtered list of options to pass through from the
1171  * client to the server.
1172  *
1173  * This involves setting options that will tell the server how to
1174  * behave, and also filtering out options that are processed only
1175  * locally.
1176  **/
1177 void server_options(char **args,int *argc)
1178 {
1179         static char argstr[50+MAX_BASIS_DIRS*2];
1180         int ac = *argc;
1181         char *arg;
1182
1183         int i, x;
1184
1185         if (blocking_io == -1)
1186                 blocking_io = 0;
1187
1188         args[ac++] = "--server";
1189
1190         if (daemon_over_rsh) {
1191                 args[ac++] = "--daemon";
1192                 *argc = ac;
1193                 /* if we're passing --daemon, we're done */
1194                 return;
1195         }
1196
1197         if (!am_sender)
1198                 args[ac++] = "--sender";
1199
1200         x = 1;
1201         argstr[0] = '-';
1202         for (i = 0; i < verbose; i++)
1203                 argstr[x++] = 'v';
1204
1205         /* the -q option is intentionally left out */
1206         if (make_backups)
1207                 argstr[x++] = 'b';
1208         if (update_only)
1209                 argstr[x++] = 'u';
1210         if (dry_run)
1211                 argstr[x++] = 'n';
1212         if (preserve_links)
1213                 argstr[x++] = 'l';
1214         if (copy_links)
1215                 argstr[x++] = 'L';
1216         if (xfer_dirs > 1)
1217                 argstr[x++] = 'd';
1218         if (keep_dirlinks && am_sender)
1219                 argstr[x++] = 'K';
1220
1221         if (whole_file > 0)
1222                 argstr[x++] = 'W';
1223         /* We don't need to send --no-whole-file, because it's the
1224          * default for remote transfers, and in any case old versions
1225          * of rsync will not understand it. */
1226
1227         if (preserve_hard_links)
1228                 argstr[x++] = 'H';
1229         if (preserve_uid)
1230                 argstr[x++] = 'o';
1231         if (preserve_gid)
1232                 argstr[x++] = 'g';
1233         if (preserve_devices)
1234                 argstr[x++] = 'D';
1235         if (preserve_times)
1236                 argstr[x++] = 't';
1237         if (omit_dir_times && am_sender)
1238                 argstr[x++] = 'O';
1239         if (preserve_perms)
1240                 argstr[x++] = 'p';
1241         if (recurse < 0)
1242                 argstr[x++] = 'r';
1243         if (always_checksum)
1244                 argstr[x++] = 'c';
1245         if (cvs_exclude)
1246                 argstr[x++] = 'C';
1247         if (ignore_times)
1248                 argstr[x++] = 'I';
1249         if (relative_paths)
1250                 argstr[x++] = 'R';
1251         if (one_file_system)
1252                 argstr[x++] = 'x';
1253         if (sparse_files)
1254                 argstr[x++] = 'S';
1255         if (do_compression)
1256                 argstr[x++] = 'z';
1257
1258         /* This is a complete hack - blame Rusty.  FIXME!
1259          * This hack is only needed for older rsync versions that
1260          * don't understand the --list-only option. */
1261         if (list_only == 1 && recurse >= 0)
1262                 argstr[x++] = 'r';
1263
1264         argstr[x] = 0;
1265
1266         if (x != 1)
1267                 args[ac++] = argstr;
1268
1269         if (list_only > 1)
1270                 args[ac++] = "--list-only";
1271
1272         if (block_size) {
1273                 if (asprintf(&arg, "-B%lu", block_size) < 0)
1274                         goto oom;
1275                 args[ac++] = arg;
1276         }
1277
1278         if (max_delete && am_sender) {
1279                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
1280                         goto oom;
1281                 args[ac++] = arg;
1282         }
1283
1284         if (max_size && am_sender) {
1285                 args[ac++] = "--max-size";
1286                 args[ac++] = max_size_arg;
1287         }
1288
1289         if (io_timeout) {
1290                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
1291                         goto oom;
1292                 args[ac++] = arg;
1293         }
1294
1295         if (bwlimit) {
1296                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
1297                         goto oom;
1298                 args[ac++] = arg;
1299         }
1300
1301         if (backup_dir) {
1302                 args[ac++] = "--backup-dir";
1303                 args[ac++] = backup_dir;
1304         }
1305
1306         /* Only send --suffix if it specifies a non-default value. */
1307         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1308                 /* We use the following syntax to avoid weirdness with '~'. */
1309                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1310                         goto oom;
1311                 args[ac++] = arg;
1312         }
1313
1314         if (am_sender) {
1315                 if (delete_excluded)
1316                         args[ac++] = "--delete-excluded";
1317                 else if (delete_before == 1 || delete_after)
1318                         args[ac++] = "--delete";
1319                 if (delete_before > 1)
1320                         args[ac++] = "--delete-before";
1321                 if (delete_during)
1322                         args[ac++] = "--delete-during";
1323                 if (delete_after)
1324                         args[ac++] = "--delete-after";
1325                 if (force_delete)
1326                         args[ac++] = "--force";
1327         }
1328
1329         if (size_only)
1330                 args[ac++] = "--size-only";
1331
1332         if (modify_window_set) {
1333                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1334                         goto oom;
1335                 args[ac++] = arg;
1336         }
1337
1338         if (checksum_seed) {
1339                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1340                         goto oom;
1341                 args[ac++] = arg;
1342         }
1343
1344         if (partial_dir && am_sender) {
1345                 if (partial_dir != partialdir_for_delayupdate) {
1346                         args[ac++] = "--partial-dir";
1347                         args[ac++] = partial_dir;
1348                 }
1349                 if (delay_updates)
1350                         args[ac++] = "--delay-updates";
1351         } else if (keep_partial)
1352                 args[ac++] = "--partial";
1353
1354         if (ignore_errors)
1355                 args[ac++] = "--ignore-errors";
1356
1357         if (copy_unsafe_links)
1358                 args[ac++] = "--copy-unsafe-links";
1359
1360         if (safe_symlinks)
1361                 args[ac++] = "--safe-links";
1362
1363         if (numeric_ids)
1364                 args[ac++] = "--numeric-ids";
1365
1366         if (only_existing && am_sender)
1367                 args[ac++] = "--existing";
1368
1369         if (opt_ignore_existing && am_sender)
1370                 args[ac++] = "--ignore-existing";
1371
1372         if (inplace)
1373                 args[ac++] = "--inplace";
1374
1375         if (tmpdir) {
1376                 args[ac++] = "--temp-dir";
1377                 args[ac++] = tmpdir;
1378         }
1379
1380         if (basis_dir[0] && am_sender) {
1381                 /* the server only needs this option if it is not the sender,
1382                  *   and it may be an older version that doesn't know this
1383                  *   option, so don't send it if client is the sender.
1384                  */
1385                 int i;
1386                 for (i = 0; i < basis_dir_cnt; i++) {
1387                         args[ac++] = dest_option;
1388                         args[ac++] = basis_dir[i];
1389                 }
1390         }
1391
1392         if (files_from && (!am_sender || remote_filesfrom_file)) {
1393                 if (remote_filesfrom_file) {
1394                         args[ac++] = "--files-from";
1395                         args[ac++] = remote_filesfrom_file;
1396                         if (eol_nulls)
1397                                 args[ac++] = "--from0";
1398                 } else {
1399                         args[ac++] = "--files-from=-";
1400                         args[ac++] = "--from0";
1401                 }
1402                 if (!relative_paths)
1403                         args[ac++] = "--no-relative";
1404         }
1405         if (!implied_dirs && !am_sender)
1406                 args[ac++] = "--no-implied-dirs";
1407
1408         if (fuzzy_basis && am_sender)
1409                 args[ac++] = "--fuzzy";
1410
1411         *argc = ac;
1412         return;
1413
1414     oom:
1415         out_of_memory("server_options");
1416 }
1417
1418 /**
1419  * Return the position of a ':' IF it is not part of a filename (i.e. as
1420  * long as it doesn't occur after a slash.
1421  */
1422 char *find_colon(char *s)
1423 {
1424         char *p, *p2;
1425
1426         p = strchr(s,':');
1427         if (!p)
1428                 return NULL;
1429
1430         /* now check to see if there is a / in the string before the : - if there is then
1431            discard the colon on the assumption that the : is part of a filename */
1432         p2 = strchr(s,'/');
1433         if (p2 && p2 < p)
1434                 return NULL;
1435
1436         return p;
1437 }