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