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 always_checksum = 0;
 146 int list_only = 0;
 147
 148 #define MAX_BATCH_NAME_LEN 256  /* Must be less than MAXPATHLEN-13 */
 149 char *batch_name = NULL;
 150
 151 static int daemon_opt;   /* sets am_daemon after option error-reporting */
 152 static int F_option_cnt = 0;
 153 static int modify_window_set;
 154 static int refused_verbose, refused_delete, refused_archive_part;
 155 static int refused_partial, refused_progress;
 156 static char *dest_option = NULL;
 157 static char *max_size_arg;
 158 static char partialdir_for_delayupdate[] = ".~tmp~";
 159
 160 /** Local address to bind.  As a character string because it's
 161  * interpreted by the IPv6 layer: should be a numeric IP4 or IP6
 162  * address, or a hostname. **/
 163 char *bind_address;
 164
 165
 166 static void print_rsync_version(enum logcode f)
 167 {
 168         char const *got_socketpair = "no ";
 169         char const *have_inplace = "no ";
 170         char const *hardlinks = "no ";
 171         char const *links = "no ";
 172         char const *ipv6 = "no ";
 173         STRUCT_STAT *dumstat;
 174
 175 #ifdef HAVE_SOCKETPAIR
 176         got_socketpair = "";
 177 #endif
 178
 179 #ifdef HAVE_FTRUNCATE
 180         have_inplace = "";
 181 #endif
 182
 183 #ifdef SUPPORT_HARD_LINKS
 184         hardlinks = "";
 185 #endif
 186
 187 #ifdef SUPPORT_LINKS
 188         links = "";
 189 #endif
 190
 191 #ifdef INET6
 192         ipv6 = "";
 193 #endif
 194
 195         rprintf(f, "%s  version %s  protocol version %d\n",
 196                 RSYNC_NAME, RSYNC_VERSION, PROTOCOL_VERSION);
 197         rprintf(f,
 198                 "Copyright (C) 1996-2005 by Andrew Tridgell and others\n");
 199         rprintf(f, "<http://rsync.samba.org/>\n");
 200         rprintf(f, "Capabilities: %d-bit files, %ssocketpairs, "
 201                 "%shard links, %ssymlinks, batchfiles, \n",
 202                 (int) (sizeof (OFF_T) * 8),
 203                 got_socketpair, hardlinks, links);
 204
 205         /* Note that this field may not have type ino_t.  It depends
 206          * on the complicated interaction between largefile feature
 207          * macros. */
 208         rprintf(f, "              %sinplace, %sIPv6, %d-bit system inums, %d-bit internal inums\n",
 209                 have_inplace, ipv6,
 210                 (int) (sizeof dumstat->st_ino * 8),
 211                 (int) (sizeof (int64) * 8));
 212 #ifdef MAINTAINER_MODE
 213         rprintf(f, "              panic action: \"%s\"\n",
 214                 get_panic_action());
 215 #endif
 216
 217 #if SIZEOF_INT64 < 8
 218         rprintf(f, "WARNING: no 64-bit integers on this platform!\n");
 219 #endif
 220         if (sizeof (int64) != SIZEOF_INT64) {
 221                 rprintf(f,
 222                         "WARNING: size mismatch in SIZEOF_INT64 define (%d != %d)\n",
 223                         (int) SIZEOF_INT64, (int) sizeof (int64));
 224         }
 225
 226         rprintf(f,
 227 "\n"
 228 "rsync comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n"
 229 "are welcome to redistribute it under certain conditions.  See the GNU\n"
 230 "General Public Licence for details.\n"
 231                 );
 232 }
 233
 234
 235 void usage(enum logcode F)
 236 {
 237   print_rsync_version(F);
 238
 239   rprintf(F,"\nrsync is a file transfer program capable of efficient remote update\nvia a fast differencing algorithm.\n\n");
 240
 241   rprintf(F,"Usage: rsync [OPTION]... SRC [SRC]... [USER@]HOST:DEST\n");
 242   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST:SRC DEST\n");
 243   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... DEST\n");
 244   rprintf(F,"  or   rsync [OPTION]... [USER@]HOST::SRC [DEST]\n");
 245   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... [USER@]HOST::DEST\n");
 246   rprintf(F,"  or   rsync [OPTION]... rsync://[USER@]HOST[:PORT]/SRC [DEST]\n");
 247   rprintf(F,"  or   rsync [OPTION]... SRC [SRC]... rsync://[USER@]HOST[:PORT]/DEST\n");
 248   rprintf(F,"SRC on single-colon remote HOST will be expanded by remote shell\n");
 249   rprintf(F,"SRC on server remote HOST may contain shell wildcards or multiple\n");
 250   rprintf(F,"  sources separated by space as long as they have same top-level\n");
 251   rprintf(F,"\nOptions\n");
 252   rprintf(F," -v, --verbose               increase verbosity\n");
 253   rprintf(F," -q, --quiet                 suppress non-error messages\n");
 254   rprintf(F," -c, --checksum              skip based on checksum, not mod-time & size\n");
 255   rprintf(F," -a, --archive               archive mode; same as -rlptgoD (no -H)\n");
 256   rprintf(F," -r, --recursive             recurse into directories\n");
 257   rprintf(F," -R, --relative              use relative path names\n");
 258   rprintf(F,"     --no-relative           turn off --relative\n");
 259   rprintf(F,"     --no-implied-dirs       don't send implied dirs with -R\n");
 260   rprintf(F," -b, --backup                make backups (see --suffix & --backup-dir)\n");
 261   rprintf(F,"     --backup-dir=DIR        make backups into hierarchy based in DIR\n");
 262   rprintf(F,"     --suffix=SUFFIX         set backup suffix (default %s w/o --backup-dir)\n",BACKUP_SUFFIX);
 263   rprintf(F," -u, --update                skip files that are newer on the receiver\n");
 264   rprintf(F,"     --inplace               update destination files in-place (SEE MAN PAGE)\n");
 265   rprintf(F," -d, --dirs                  transfer directories without recursing\n");
 266   rprintf(F," -l, --links                 copy symlinks as symlinks\n");
 267   rprintf(F," -L, --copy-links            transform symlink into referent file/dir\n");
 268   rprintf(F,"     --copy-unsafe-links     only \"unsafe\" symlinks are transformed\n");
 269   rprintf(F,"     --safe-links            ignore symlinks that point outside the source tree\n");
 270   rprintf(F," -H, --hard-links            preserve hard links\n");
 271   rprintf(F," -K, --keep-dirlinks         treat symlinked dir on receiver as dir\n");
 272   rprintf(F," -p, --perms                 preserve permissions\n");
 273   rprintf(F," -o, --owner                 preserve owner (root only)\n");
 274   rprintf(F," -g, --group                 preserve group\n");
 275   rprintf(F," -D, --devices               preserve devices (root only)\n");
 276   rprintf(F," -t, --times                 preserve times\n");
 277   rprintf(F," -O, --omit-dir-times        omit directories when preserving times\n");
 278   rprintf(F," -S, --sparse                handle sparse files efficiently\n");
 279   rprintf(F," -n, --dry-run               show what would have been transferred\n");
 280   rprintf(F," -W, --whole-file            copy files whole (without rsync algorithm)\n");
 281   rprintf(F,"     --no-whole-file         always use incremental rsync algorithm\n");
 282   rprintf(F," -x, --one-file-system       don't cross filesystem boundaries\n");
 283   rprintf(F," -B, --block-size=SIZE       force a fixed checksum block-size\n");
 284   rprintf(F," -e, --rsh=COMMAND           specify the remote shell to use\n");
 285   rprintf(F,"     --rsync-path=PATH       specify path to rsync on the remote machine\n");
 286   rprintf(F,"     --existing              only update files that already exist on receiver\n");
 287   rprintf(F,"     --ignore-existing       ignore files that already exist on receiving side\n");
 288   rprintf(F,"     --del                   an alias for --delete-during\n");
 289   rprintf(F,"     --delete                delete files that don't exist on the sending side\n");
 290   rprintf(F,"     --delete-before         receiver deletes before transfer (default)\n");
 291   rprintf(F,"     --delete-during         receiver deletes during transfer, not before\n");
 292   rprintf(F,"     --delete-after          receiver deletes after transfer, not before\n");
 293   rprintf(F,"     --delete-excluded       also delete excluded files on the receiving side\n");
 294   rprintf(F,"     --ignore-errors         delete even if there are I/O errors\n");
 295   rprintf(F,"     --force                 force deletion of directories even if not empty\n");
 296   rprintf(F,"     --max-delete=NUM        don't delete more than NUM files\n");
 297   rprintf(F,"     --max-size=SIZE         don't transfer any file larger than SIZE\n");
 298   rprintf(F,"     --partial               keep partially transferred files\n");
 299   rprintf(F,"     --partial-dir=DIR       put a partially transferred file into DIR\n");
 300   rprintf(F,"     --delay-updates         put all updated files into place at transfer's end\n");
 301   rprintf(F,"     --numeric-ids           don't map uid/gid values by user/group name\n");
 302   rprintf(F,"     --timeout=TIME          set I/O timeout in seconds\n");
 303   rprintf(F," -I, --ignore-times          don't skip files that match in size and mod-time\n");
 304   rprintf(F,"     --size-only             skip files that match in size\n");
 305   rprintf(F,"     --modify-window=NUM     compare mod-times with reduced accuracy\n");
 306   rprintf(F," -T, --temp-dir=DIR          create temporary files in directory DIR\n");
 307   rprintf(F," -y, --fuzzy                 find similar file for basis if no dest file\n");
 308   rprintf(F,"     --compare-dest=DIR      also compare destination files relative to DIR\n");
 309   rprintf(F,"     --copy-dest=DIR         ... and include copies of unchanged files\n");
 310   rprintf(F,"     --link-dest=DIR         hardlink to files in DIR when unchanged\n");
 311   rprintf(F," -z, --compress              compress file data during the transfer\n");
 312   rprintf(F," -C, --cvs-exclude           auto-ignore files the same way CVS does\n");
 313   rprintf(F," -f, --filter=RULE           add a file-filtering RULE\n");
 314   rprintf(F," -F                          same as --filter='dir-merge /.rsync-filter'\n");
 315   rprintf(F,"                             repeated: --filter='- .rsync-filter'\n");
 316   rprintf(F,"     --exclude=PATTERN       exclude files matching PATTERN\n");
 317   rprintf(F,"     --exclude-from=FILE     read exclude patterns from FILE\n");
 318   rprintf(F,"     --include=PATTERN       don't exclude files matching PATTERN\n");
 319   rprintf(F,"     --include-from=FILE     read include patterns from FILE\n");
 320   rprintf(F,"     --files-from=FILE       read list of source-file names from FILE\n");
 321   rprintf(F," -0, --from0                 all *-from file lists are delimited by nulls\n");
 322   rprintf(F,"     --version               print version number\n");
 323   rprintf(F,"     --port=PORT             specify double-colon alternate port number\n");
 324   rprintf(F,"     --blocking-io           use blocking I/O for the remote shell\n");
 325   rprintf(F,"     --no-blocking-io        turn off blocking I/O when it is the default\n");
 326   rprintf(F,"     --stats                 give some file-transfer stats\n");
 327   rprintf(F,"     --progress              show progress during transfer\n");
 328   rprintf(F," -P                          same as --partial --progress\n");
 329   rprintf(F," -i, --itemize-changes       output a change-summary for all updates\n");
 330   rprintf(F,"     --log-format=FORMAT     log file-transfers using specified format\n");
 331   rprintf(F,"     --password-file=FILE    read password from FILE\n");
 332   rprintf(F,"     --list-only             list the files instead of copying them\n");
 333   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
 334   rprintf(F,"     --write-batch=FILE      write a batched update to FILE\n");
 335   rprintf(F,"     --read-batch=FILE       read a batched update from FILE\n");
 336 #ifdef INET6
 337   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 338   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 339 #endif
 340   rprintf(F," -h, --help                  show this help screen\n");
 341
 342   rprintf(F,"\nUse \"rsync --daemon --help\" to see the daemon-mode command-line options.\n");
 343   rprintf(F,"Please see the rsync(1) and rsyncd.conf(5) man pages for full documentation.\n");
 344   rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
 345 }
 346
 347 enum {OPT_VERSION = 1000, OPT_DAEMON, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
 348       OPT_FILTER, OPT_COMPARE_DEST, OPT_COPY_DEST, OPT_LINK_DEST,
 349       OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
 350       OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_TIMEOUT, OPT_MAX_SIZE,
 351       OPT_REFUSED_BASE = 9000};
 352
 353 static struct poptOption long_options[] = {
 354   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 355   {"version",          0,  POPT_ARG_NONE,   0, OPT_VERSION, 0, 0},
 356   {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
 357   {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path, 0, 0, 0 },
 358   {"password-file",    0,  POPT_ARG_STRING, &password_file, 0, 0, 0 },
 359   {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
 360   {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
 361   {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
 362   {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system, 0, 0, 0 },
 363   {"existing",         0,  POPT_ARG_NONE,   &only_existing, 0, 0, 0 },
 364   {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing, 0, 0, 0 },
 365   {"del",              0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 366   {"delete",           0,  POPT_ARG_NONE,   &delete_mode, 0, 0, 0 },
 367   {"delete-before",    0,  POPT_ARG_VAL,    &delete_before, 2, 0, 0 },
 368   {"delete-during",    0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 369   {"delete-after",     0,  POPT_ARG_NONE,   &delete_after, 0, 0, 0 },
 370   {"delete-excluded",  0,  POPT_ARG_NONE,   &delete_excluded, 0, 0, 0 },
 371   {"force",            0,  POPT_ARG_NONE,   &force_delete, 0, 0, 0 },
 372   {"numeric-ids",      0,  POPT_ARG_NONE,   &numeric_ids, 0, 0, 0 },
 373   {"filter",          'f', POPT_ARG_STRING, 0, OPT_FILTER, 0, 0 },
 374   {"exclude",          0,  POPT_ARG_STRING, 0, OPT_EXCLUDE, 0, 0 },
 375   {"include",          0,  POPT_ARG_STRING, 0, OPT_INCLUDE, 0, 0 },
 376   {"exclude-from",     0,  POPT_ARG_STRING, 0, OPT_EXCLUDE_FROM, 0, 0 },
 377   {"include-from",     0,  POPT_ARG_STRING, 0, OPT_INCLUDE_FROM, 0, 0 },
 378   {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
 379   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 380   {"backup",          'b', POPT_ARG_NONE,   &make_backups, 0, 0, 0 },
 381   {"dry-run",         'n', POPT_ARG_NONE,   &dry_run, 0, 0, 0 },
 382   {"sparse",          'S', POPT_ARG_NONE,   &sparse_files, 0, 0, 0 },
 383   {"cvs-exclude",     'C', POPT_ARG_NONE,   &cvs_exclude, 0, 0, 0 },
 384   {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
 385   {"inplace",          0,  POPT_ARG_NONE,   &inplace, 0, 0, 0 },
 386   {"dirs",            'd', POPT_ARG_VAL,    &xfer_dirs, 2, 0, 0 },
 387   {"links",           'l', POPT_ARG_NONE,   &preserve_links, 0, 0, 0 },
 388   {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
 389   {"keep-dirlinks",   'K', POPT_ARG_NONE,   &keep_dirlinks, 0, 0, 0 },
 390   {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
 391   {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 392   {"copy-unsafe-links",0,  POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
 393   {"perms",           'p', POPT_ARG_NONE,   &preserve_perms, 0, 0, 0 },
 394   {"owner",           'o', POPT_ARG_NONE,   &preserve_uid, 0, 0, 0 },
 395   {"group",           'g', POPT_ARG_NONE,   &preserve_gid, 0, 0, 0 },
 396   {"devices",         'D', POPT_ARG_NONE,   &preserve_devices, 0, 0, 0 },
 397   {"times",           't', POPT_ARG_NONE,   &preserve_times, 0, 0, 0 },
 398   {"omit-dir-times",  'O', POPT_ARG_NONE,   &omit_dir_times, 0, 0, 0 },
 399   {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
 400   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 401   {"quiet",           'q', POPT_ARG_NONE,   0, 'q', 0, 0 },
 402   {"archive",         'a', POPT_ARG_NONE,   &archive_mode, 0, 0, 0 },
 403   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 404   {"sender",           0,  POPT_ARG_NONE,   0, OPT_SENDER, 0, 0 },
 405   {"recursive",       'r', POPT_ARG_VAL,    &recurse, -1, 0, 0 },
 406   {"list-only",        0,  POPT_ARG_VAL,    &list_only, 2, 0, 0 },
 407   {"relative",        'R', POPT_ARG_VAL,    &relative_paths, 1, 0, 0 },
 408   {"no-relative",      0,  POPT_ARG_VAL,    &relative_paths, 0, 0, 0 },
 409   {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
 410   {"block-size",      'B', POPT_ARG_LONG,   &block_size, 0, 0, 0 },
 411   {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
 412   {"max-size",         0,  POPT_ARG_STRING, &max_size_arg,  OPT_MAX_SIZE, 0, 0 },
 413   {"timeout",          0,  POPT_ARG_INT,    &io_timeout, OPT_TIMEOUT, 0, 0 },
 414   {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
 415   {"compare-dest",     0,  POPT_ARG_STRING, 0, OPT_COMPARE_DEST, 0, 0 },
 416   {"copy-dest",        0,  POPT_ARG_STRING, 0, OPT_COPY_DEST, 0, 0 },
 417   {"link-dest",        0,  POPT_ARG_STRING, 0, OPT_LINK_DEST, 0, 0 },
 418   {"fuzzy",           'y', POPT_ARG_NONE,   &fuzzy_basis, 0, 0, 0 },
 419   /* TODO: Should this take an optional int giving the compression level? */
 420   {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
 421   {"stats",            0,  POPT_ARG_NONE,   &do_stats, 0, 0, 0 },
 422   {"progress",         0,  POPT_ARG_NONE,   &do_progress, 0, 0, 0 },
 423   {"partial",          0,  POPT_ARG_NONE,   &keep_partial, 0, 0, 0 },
 424   {"partial-dir",      0,  POPT_ARG_STRING, &partial_dir, 0, 0, 0 },
 425   {"delay-updates",    0,  POPT_ARG_NONE,   &delay_updates, 0, 0, 0 },
 426   {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors, 0, 0, 0 },
 427   {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
 428   {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
 429   {0,                 'F', POPT_ARG_NONE,   0, 'F', 0, 0 },
 430   {0,                 'P', POPT_ARG_NONE,   0, 'P', 0, 0 },
 431   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 432   {"log-format",       0,  POPT_ARG_STRING, &log_format, 0, 0, 0 },
 433   {"itemize-changes", 'i', POPT_ARG_NONE,   &itemize_changes, 0, 0, 0 },
 434   {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
 435   {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
 436   {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links, 0, 0, 0 },
 437   {"read-batch",       0,  POPT_ARG_STRING, &batch_name, OPT_READ_BATCH, 0, 0 },
 438   {"write-batch",      0,  POPT_ARG_STRING, &batch_name, OPT_WRITE_BATCH, 0, 0 },
 439   {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
 440   {"from0",           '0', POPT_ARG_NONE,   &eol_nulls, 0, 0, 0},
 441   {"no-implied-dirs",  0,  POPT_ARG_VAL,    &implied_dirs, 0, 0, 0 },
 442   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 443   {"checksum-seed",    0,  POPT_ARG_INT,    &checksum_seed, 0, 0, 0 },
 444 #ifdef INET6
 445   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 446   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 447 #endif
 448   /* All these options switch us into daemon-mode option-parsing. */
 449   {"address",          0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
 450   {"config",           0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
 451   {"daemon",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 452   {"no-detach",        0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 453   {0,0,0,0, 0, 0, 0}
 454 };
 455
 456 static void daemon_usage(enum logcode F)
 457 {
 458   print_rsync_version(F);
 459
 460   rprintf(F,"\nUsage: rsync --daemon [OPTION]...\n");
 461   rprintf(F,"     --address=ADDRESS       bind to the specified address\n");
 462   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
 463   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");
 464   rprintf(F,"     --no-detach             do not detach from the parent\n");
 465   rprintf(F,"     --port=PORT             listen on alternate port number\n");
 466   rprintf(F," -v, --verbose               increase verbosity\n");
 467 #ifdef INET6
 468   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 469   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 470 #endif
 471   rprintf(F," -h, --help                  show this help screen\n");
 472
 473   rprintf(F,"\nIf you were not trying to invoke rsync as a daemon, avoid using any of the\n");
 474   rprintf(F,"daemon-specific rsync options.  See also the rsyncd.conf(5) man page.\n");
 475 }
 476
 477 static struct poptOption long_daemon_options[] = {
 478   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 479   {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
 480   {"bwlimit",          0,  POPT_ARG_INT,    &daemon_bwlimit, 0, 0, 0 },
 481   {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
 482   {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
 483 #ifdef INET6
 484   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 485   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 486 #endif
 487   {"no-detach",        0,  POPT_ARG_NONE,   &no_detach, 0, 0, 0 },
 488   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 489   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 490   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 491   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 492   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 493   {0,0,0,0, 0, 0, 0}
 494 };
 495
 496
 497 static char err_buf[200];
 498
 499
 500 /**
 501  * Store the option error message, if any, so that we can log the
 502  * connection attempt (which requires parsing the options), and then
 503  * show the error later on.
 504  **/
 505 void option_error(void)
 506 {
 507         if (!err_buf[0]) {
 508                 strcpy(err_buf, "Error parsing options: "
 509                     "option may be supported on client but not on server?\n");
 510         }
 511
 512         rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
 513 }
 514
 515
 516 /**
 517  * Tweak the option table to disable all options that the rsyncd.conf
 518  * file has told us to refuse.
 519  **/
 520 static void set_refuse_options(char *bp)
 521 {
 522         struct poptOption *op;
 523         char *cp, shortname[2];
 524         int is_wild, found_match;
 525
 526         shortname[1] = '\0';
 527
 528         while (1) {
 529                 while (*bp == ' ') bp++;
 530                 if (!*bp)
 531                         break;
 532                 if ((cp = strchr(bp, ' ')) != NULL)
 533                         *cp= '\0';
 534                 is_wild = strpbrk(bp, "*?[") != NULL;
 535                 found_match = 0;
 536                 for (op = long_options; ; op++) {
 537                         *shortname = op->shortName;
 538                         if (!op->longName && !*shortname)
 539                                 break;
 540                         if ((op->longName && wildmatch(bp, op->longName))
 541                             || (*shortname && wildmatch(bp, shortname))
 542                             || op->val == OPT_DAEMON) {
 543                                 if (op->argInfo == POPT_ARG_VAL)
 544                                         op->argInfo = POPT_ARG_NONE;
 545                                 op->val = (op - long_options) + OPT_REFUSED_BASE;
 546                                 found_match = 1;
 547                                 /* These flags are set to let us easily check
 548                                  * an implied option later in the code. */
 549                                 switch (*shortname) {
 550                                 case 'v':
 551                                         refused_verbose = op->val;
 552                                         break;
 553                                 case 'r': case 'd': case 'l': case 'p':
 554                                 case 't': case 'g': case 'o': case 'D':
 555                                         refused_archive_part = op->val;
 556                                         break;
 557                                 case '\0':
 558                                         if (wildmatch("delete", op->longName))
 559                                                 refused_delete = 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                 delete_mode = delete_before = 1;
 958
 959         if (delete_mode && refused_delete) {
 960                 create_refuse_error(refused_delete);
 961                 return 0;
 962         }
 963
 964         *argv = poptGetArgs(pc);
 965         *argc = count_args(*argv);
 966
 967         if (sanitize_paths) {
 968                 int i;
 969                 for (i = *argc; i-- > 0; )
 970                         (*argv)[i] = sanitize_path(NULL, (*argv)[i], "", 0);
 971                 if (tmpdir)
 972                         tmpdir = sanitize_path(NULL, tmpdir, NULL, 0);
 973                 if (partial_dir)
 974                         partial_dir = sanitize_path(NULL, partial_dir, NULL, 0);
 975                 if (backup_dir)
 976                         backup_dir = sanitize_path(NULL, backup_dir, NULL, 0);
 977                 if (files_from)
 978                         files_from = sanitize_path(NULL, files_from, NULL, 0);
 979         }
 980         if (server_filter_list.head && !am_sender) {
 981                 struct filter_list_struct *elp = &server_filter_list;
 982                 int i;
 983                 if (tmpdir) {
 984                         if (!*tmpdir)
 985                                 goto options_rejected;
 986                         clean_fname(tmpdir, 1);
 987                         if (check_filter(elp, tmpdir, 1) < 0)
 988                                 goto options_rejected;
 989                 }
 990                 if (partial_dir && *partial_dir) {
 991                         clean_fname(partial_dir, 1);
 992                         if (check_filter(elp, partial_dir, 1) < 0)
 993                                 goto options_rejected;
 994                 }
 995                 for (i = 0; i < basis_dir_cnt; i++) {
 996                         if (!*basis_dir[i])
 997                                 goto options_rejected;
 998                         clean_fname(basis_dir[i], 1);
 999                         if (check_filter(elp, basis_dir[i], 1) < 0)
1000                                 goto options_rejected;
1001                 }
1002                 if (backup_dir) {
1003                         if (!*backup_dir)
1004                                 goto options_rejected;
1005                         clean_fname(backup_dir, 1);
1006                         if (check_filter(elp, backup_dir, 1) < 0)
1007                                 goto options_rejected;
1008                 }
1009         }
1010         if (server_filter_list.head && files_from) {
1011                 if (!*files_from)
1012                         goto options_rejected;
1013                 clean_fname(files_from, 1);
1014                 if (check_filter(&server_filter_list, files_from, 0) < 0) {
1015                     options_rejected:
1016                         snprintf(err_buf, sizeof err_buf,
1017                             "Your options have been rejected by the server.\n");
1018                         return 0;
1019                 }
1020         }
1021
1022         if (!backup_suffix)
1023                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
1024         backup_suffix_len = strlen(backup_suffix);
1025         if (strchr(backup_suffix, '/') != NULL) {
1026                 snprintf(err_buf, sizeof err_buf,
1027                         "--suffix cannot contain slashes: %s\n",
1028                         backup_suffix);
1029                 return 0;
1030         }
1031         if (backup_dir) {
1032                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
1033                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
1034                 if (backup_dir_remainder < 32) {
1035                         snprintf(err_buf, sizeof err_buf,
1036                                 "the --backup-dir path is WAY too long.\n");
1037                         return 0;
1038                 }
1039                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
1040                         backup_dir_buf[backup_dir_len++] = '/';
1041                         backup_dir_buf[backup_dir_len] = '\0';
1042                 }
1043                 if (verbose > 1 && !am_sender) {
1044                         rprintf(FINFO, "backup_dir is %s\n",
1045                                 safe_fname(backup_dir_buf));
1046                 }
1047         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
1048                 snprintf(err_buf, sizeof err_buf,
1049                         "--suffix cannot be a null string without --backup-dir\n");
1050                 return 0;
1051         }
1052
1053         if (do_progress && !verbose && !itemize_changes) {
1054                 if (refused_verbose) {
1055                         create_refuse_error(refused_verbose);
1056                         return 0;
1057                 }
1058                 verbose = 1;
1059         }
1060
1061         if (daemon_bwlimit && (!bwlimit || bwlimit > daemon_bwlimit))
1062                 bwlimit = daemon_bwlimit;
1063         if (bwlimit) {
1064                 bwlimit_writemax = (size_t)bwlimit * 128;
1065                 if (bwlimit_writemax < 512)
1066                         bwlimit_writemax = 512;
1067         }
1068
1069         if (delay_updates && !partial_dir)
1070                 partial_dir = partialdir_for_delayupdate;
1071
1072         if (inplace) {
1073 #ifdef HAVE_FTRUNCATE
1074                 if (partial_dir) {
1075                         snprintf(err_buf, sizeof err_buf,
1076                                  "--inplace cannot be used with --%s\n",
1077                                  delay_updates ? "delay-updates" : "partial-dir");
1078                         return 0;
1079                 }
1080                 /* --inplace implies --partial for refusal purposes, but we
1081                  * clear the keep_partial flag for internal logic purposes. */
1082                 if (refused_partial) {
1083                         create_refuse_error(refused_partial);
1084                         return 0;
1085                 }
1086                 keep_partial = 0;
1087 #else
1088                 snprintf(err_buf, sizeof err_buf,
1089                          "--inplace is not supported on this %s\n",
1090                          am_server ? "server" : "client");
1091                 return 0;
1092 #endif
1093         } else {
1094                 if (keep_partial && !partial_dir) {
1095                         if ((arg = getenv("RSYNC_PARTIAL_DIR")) != NULL && *arg)
1096                                 partial_dir = strdup(arg);
1097                 }
1098                 if (partial_dir) {
1099                         if (*partial_dir)
1100                                 clean_fname(partial_dir, 1);
1101                         if (!*partial_dir || strcmp(partial_dir, ".") == 0)
1102                                 partial_dir = NULL;
1103                         else if (*partial_dir != '/') {
1104                                 parse_rule(&filter_list, partial_dir,
1105                                     MATCHFLG_NO_PREFIXES|MATCHFLG_DIRECTORY, 0);
1106                         }
1107                         if (!partial_dir && refused_partial) {
1108                                 create_refuse_error(refused_partial);
1109                                 return 0;
1110                         }
1111                         keep_partial = 1;
1112                 }
1113         }
1114
1115         if (files_from) {
1116                 char *colon;
1117                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
1118                         usage(FERROR);
1119                         exit_cleanup(RERR_SYNTAX);
1120                 }
1121                 if (strcmp(files_from, "-") == 0) {
1122                         filesfrom_fd = 0;
1123                         if (am_server)
1124                                 remote_filesfrom_file = "-";
1125                 }
1126                 else if ((colon = find_colon(files_from)) != 0) {
1127                         if (am_server) {
1128                                 usage(FERROR);
1129                                 exit_cleanup(RERR_SYNTAX);
1130                         }
1131                         remote_filesfrom_file = colon+1 + (colon[1] == ':');
1132                         if (strcmp(remote_filesfrom_file, "-") == 0) {
1133                                 snprintf(err_buf, sizeof err_buf,
1134                                         "Invalid --files-from remote filename\n");
1135                                 return 0;
1136                         }
1137                 } else {
1138                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
1139                         if (filesfrom_fd < 0) {
1140                                 snprintf(err_buf, sizeof err_buf,
1141                                         "failed to open files-from file %s: %s\n",
1142                                         files_from, strerror(errno));
1143                                 return 0;
1144                         }
1145                 }
1146         }
1147
1148         return 1;
1149 }
1150
1151
1152 /**
1153  * Construct a filtered list of options to pass through from the
1154  * client to the server.
1155  *
1156  * This involves setting options that will tell the server how to
1157  * behave, and also filtering out options that are processed only
1158  * locally.
1159  **/
1160 void server_options(char **args,int *argc)
1161 {
1162         static char argstr[50+MAX_BASIS_DIRS*2];
1163         int ac = *argc;
1164         char *arg;
1165
1166         int i, x;
1167
1168         if (blocking_io == -1)
1169                 blocking_io = 0;
1170
1171         args[ac++] = "--server";
1172
1173         if (daemon_over_rsh) {
1174                 args[ac++] = "--daemon";
1175                 *argc = ac;
1176                 /* if we're passing --daemon, we're done */
1177                 return;
1178         }
1179
1180         if (!am_sender)
1181                 args[ac++] = "--sender";
1182
1183         x = 1;
1184         argstr[0] = '-';
1185         for (i = 0; i < verbose; i++)
1186                 argstr[x++] = 'v';
1187
1188         /* the -q option is intentionally left out */
1189         if (make_backups)
1190                 argstr[x++] = 'b';
1191         if (update_only)
1192                 argstr[x++] = 'u';
1193         if (dry_run)
1194                 argstr[x++] = 'n';
1195         if (preserve_links)
1196                 argstr[x++] = 'l';
1197         if (copy_links)
1198                 argstr[x++] = 'L';
1199         if (xfer_dirs > 1)
1200                 argstr[x++] = 'd';
1201         if (keep_dirlinks && am_sender)
1202                 argstr[x++] = 'K';
1203
1204         if (whole_file > 0)
1205                 argstr[x++] = 'W';
1206         /* We don't need to send --no-whole-file, because it's the
1207          * default for remote transfers, and in any case old versions
1208          * of rsync will not understand it. */
1209
1210         if (itemize_changes && am_sender)
1211                 argstr[x++] = 'i';
1212         if (preserve_hard_links)
1213                 argstr[x++] = 'H';
1214         if (preserve_uid)
1215                 argstr[x++] = 'o';
1216         if (preserve_gid)
1217                 argstr[x++] = 'g';
1218         if (preserve_devices)
1219                 argstr[x++] = 'D';
1220         if (preserve_times)
1221                 argstr[x++] = 't';
1222         if (omit_dir_times && am_sender)
1223                 argstr[x++] = 'O';
1224         if (preserve_perms)
1225                 argstr[x++] = 'p';
1226         if (recurse < 0)
1227                 argstr[x++] = 'r';
1228         if (always_checksum)
1229                 argstr[x++] = 'c';
1230         if (cvs_exclude)
1231                 argstr[x++] = 'C';
1232         if (ignore_times)
1233                 argstr[x++] = 'I';
1234         if (relative_paths)
1235                 argstr[x++] = 'R';
1236         if (one_file_system)
1237                 argstr[x++] = 'x';
1238         if (sparse_files)
1239                 argstr[x++] = 'S';
1240         if (do_compression)
1241                 argstr[x++] = 'z';
1242
1243         /* This is a complete hack - blame Rusty.  FIXME!
1244          * This hack is only needed for older rsync versions that
1245          * don't understand the --list-only option. */
1246         if (list_only == 1 && recurse >= 0)
1247                 argstr[x++] = 'r';
1248
1249         argstr[x] = 0;
1250
1251         if (x != 1)
1252                 args[ac++] = argstr;
1253
1254         if (list_only > 1)
1255                 args[ac++] = "--list-only";
1256
1257         if (block_size) {
1258                 if (asprintf(&arg, "-B%lu", block_size) < 0)
1259                         goto oom;
1260                 args[ac++] = arg;
1261         }
1262
1263         if (max_delete && am_sender) {
1264                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
1265                         goto oom;
1266                 args[ac++] = arg;
1267         }
1268
1269         if (max_size && am_sender) {
1270                 args[ac++] = "--max-size";
1271                 args[ac++] = max_size_arg;
1272         }
1273
1274         if (io_timeout) {
1275                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
1276                         goto oom;
1277                 args[ac++] = arg;
1278         }
1279
1280         if (bwlimit) {
1281                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
1282                         goto oom;
1283                 args[ac++] = arg;
1284         }
1285
1286         if (backup_dir) {
1287                 args[ac++] = "--backup-dir";
1288                 args[ac++] = backup_dir;
1289         }
1290
1291         /* Only send --suffix if it specifies a non-default value. */
1292         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1293                 /* We use the following syntax to avoid weirdness with '~'. */
1294                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1295                         goto oom;
1296                 args[ac++] = arg;
1297         }
1298
1299         if (am_sender) {
1300                 if (delete_excluded)
1301                         args[ac++] = "--delete-excluded";
1302                 else if (delete_before == 1 || delete_after)
1303                         args[ac++] = "--delete";
1304                 if (delete_before > 1)
1305                         args[ac++] = "--delete-before";
1306                 if (delete_during)
1307                         args[ac++] = "--delete-during";
1308                 if (delete_after)
1309                         args[ac++] = "--delete-after";
1310                 if (force_delete)
1311                         args[ac++] = "--force";
1312         }
1313
1314         if (size_only)
1315                 args[ac++] = "--size-only";
1316
1317         if (modify_window_set) {
1318                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1319                         goto oom;
1320                 args[ac++] = arg;
1321         }
1322
1323         if (checksum_seed) {
1324                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1325                         goto oom;
1326                 args[ac++] = arg;
1327         }
1328
1329         if (partial_dir && am_sender) {
1330                 if (partial_dir != partialdir_for_delayupdate) {
1331                         args[ac++] = "--partial-dir";
1332                         args[ac++] = partial_dir;
1333                 }
1334                 if (delay_updates)
1335                         args[ac++] = "--delay-updates";
1336         } else if (keep_partial)
1337                 args[ac++] = "--partial";
1338
1339         if (ignore_errors)
1340                 args[ac++] = "--ignore-errors";
1341
1342         if (copy_unsafe_links)
1343                 args[ac++] = "--copy-unsafe-links";
1344
1345         if (safe_symlinks)
1346                 args[ac++] = "--safe-links";
1347
1348         if (numeric_ids)
1349                 args[ac++] = "--numeric-ids";
1350
1351         if (only_existing && am_sender)
1352                 args[ac++] = "--existing";
1353
1354         if (opt_ignore_existing && am_sender)
1355                 args[ac++] = "--ignore-existing";
1356
1357         if (inplace)
1358                 args[ac++] = "--inplace";
1359
1360         if (tmpdir) {
1361                 args[ac++] = "--temp-dir";
1362                 args[ac++] = tmpdir;
1363         }
1364
1365         if (basis_dir[0] && am_sender) {
1366                 /* the server only needs this option if it is not the sender,
1367                  *   and it may be an older version that doesn't know this
1368                  *   option, so don't send it if client is the sender.
1369                  */
1370                 int i;
1371                 for (i = 0; i < basis_dir_cnt; i++) {
1372                         args[ac++] = dest_option;
1373                         args[ac++] = basis_dir[i];
1374                 }
1375         }
1376
1377         if (files_from && (!am_sender || remote_filesfrom_file)) {
1378                 if (remote_filesfrom_file) {
1379                         args[ac++] = "--files-from";
1380                         args[ac++] = remote_filesfrom_file;
1381                         if (eol_nulls)
1382                                 args[ac++] = "--from0";
1383                 } else {
1384                         args[ac++] = "--files-from=-";
1385                         args[ac++] = "--from0";
1386                 }
1387                 if (!relative_paths)
1388                         args[ac++] = "--no-relative";
1389         }
1390         if (!implied_dirs && !am_sender)
1391                 args[ac++] = "--no-implied-dirs";
1392
1393         if (fuzzy_basis && am_sender)
1394                 args[ac++] = "--fuzzy";
1395
1396         *argc = ac;
1397         return;
1398
1399     oom:
1400         out_of_memory("server_options");
1401 }
1402
1403 /**
1404  * Return the position of a ':' IF it is not part of a filename (i.e. as
1405  * long as it doesn't occur after a slash.
1406  */
1407 char *find_colon(char *s)
1408 {
1409         char *p, *p2;
1410
1411         p = strchr(s,':');
1412         if (!p)
1413                 return NULL;
1414
1415         /* now check to see if there is a / in the string before the : - if there is then
1416            discard the colon on the assumption that the : is part of a filename */
1417         p2 = strchr(s,'/');
1418         if (p2 && p2 < p)
1419                 return NULL;
1420
1421         return p;
1422 }