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 local_server = 0;
  57 int ignore_times = 0;
  58 int delete_mode = 0;
  59 int delete_during = 0;
  60 int delete_before = 0;
  61 int delete_after = 0;
  62 int delete_excluded = 0;
  63 int one_file_system = 0;
  64 int protocol_version = PROTOCOL_VERSION;
  65 int sparse_files = 0;
  66 int do_compression = 0;
  67 int am_root = 0;
  68 int orig_umask = 0;
  69 int relative_paths = -1;
  70 int implied_dirs = 1;
  71 int numeric_ids = 0;
  72 int force_delete = 0;
  73 int io_timeout = 0;
  74 int am_server = 0;
  75 int am_sender = -1;
  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, 0);
 661                         break;
 662
 663                 case OPT_EXCLUDE:
 664                         add_filter(&filter_list, poptGetOptArg(pc),
 665                                    0, XFLG_OLD_PREFIXES);
 666                         break;
 667
 668                 case OPT_INCLUDE:
 669                         add_filter(&filter_list, poptGetOptArg(pc),
 670                                    MATCHFLG_INCLUDE, XFLG_OLD_PREFIXES);
 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,
 685                             opt == OPT_INCLUDE_FROM ? MATCHFLG_INCLUDE : 0,
 686                             XFLG_FATAL_ERRORS | XFLG_OLD_PREFIXES);
 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,": /.rsync-filter",0,0);
 714                                 break;
 715                         case 2:
 716                                 add_filter(&filter_list,"- .rsync-filter",0,0);
 717                                 break;
 718                         }
 719                         break;
 720
 721                 case 'P':
 722                         do_progress = 1;
 723                         keep_partial = 1;
 724                         break;
 725
 726                 case OPT_WRITE_BATCH:
 727                         /* batch_name is already set */
 728                         write_batch = 1;
 729                         break;
 730
 731                 case OPT_READ_BATCH:
 732                         /* batch_name is already set */
 733                         read_batch = 1;
 734                         break;
 735
 736                 case OPT_MAX_SIZE:
 737                         for (arg = max_size_arg; isdigit(*(uchar*)arg); arg++) {}
 738                         if (*arg == '.')
 739                                 for (arg++; isdigit(*(uchar*)arg); arg++) {}
 740                         switch (*arg) {
 741                         case 'k': case 'K':
 742                                 max_size = atof(max_size_arg) * 1024;
 743                                 break;
 744                         case 'm': case 'M':
 745                                 max_size = atof(max_size_arg) * 1024*1024;
 746                                 break;
 747                         case 'g': case 'G':
 748                                 max_size = atof(max_size_arg) * 1024*1024*1024;
 749                                 break;
 750                         case '\0':
 751                                 max_size = atof(max_size_arg);
 752                                 break;
 753                         default:
 754                                 max_size = 0;
 755                                 break;
 756                         }
 757                         if (max_size <= 0) {
 758                                 snprintf(err_buf, sizeof err_buf,
 759                                         "--max-size value is invalid: %s\n",
 760                                         max_size_arg);
 761                                 return 0;
 762                         }
 763                         break;
 764
 765                 case OPT_TIMEOUT:
 766                         if (io_timeout && io_timeout < select_timeout)
 767                                 select_timeout = io_timeout;
 768                         break;
 769
 770                 case OPT_LINK_DEST:
 771 #if HAVE_LINK
 772                         link_dest = 1;
 773                         dest_option = "--link-dest";
 774                         goto set_dest_dir;
 775 #else
 776                         snprintf(err_buf, sizeof err_buf,
 777                                  "hard links are not supported on this %s\n",
 778                                  am_server ? "server" : "client");
 779                         return 0;
 780 #endif
 781
 782                 case OPT_COPY_DEST:
 783                         copy_dest = 1;
 784                         dest_option = "--copy-dest";
 785                         goto set_dest_dir;
 786
 787                 case OPT_COMPARE_DEST:
 788                         compare_dest = 1;
 789                         dest_option = "--compare-dest";
 790                 set_dest_dir:
 791                         if (basis_dir_cnt >= MAX_BASIS_DIRS) {
 792                                 snprintf(err_buf, sizeof err_buf,
 793                                         "ERROR: at most %d %s args may be specified\n",
 794                                         MAX_BASIS_DIRS, dest_option);
 795                                 return 0;
 796                         }
 797                         arg = poptGetOptArg(pc);
 798                         if (sanitize_paths)
 799                                 arg = sanitize_path(NULL, arg, NULL, 0);
 800                         basis_dir[basis_dir_cnt++] = (char *)arg;
 801                         break;
 802
 803                 default:
 804                         /* A large opt value means that set_refuse_options()
 805                          * turned this option off (opt-BASE is its index). */
 806                         if (opt >= OPT_REFUSED_BASE) {
 807                                 struct poptOption *op =
 808                                     &long_options[opt-OPT_REFUSED_BASE];
 809                                 int n = snprintf(err_buf, sizeof err_buf,
 810                                     "The server is configured to refuse --%s\n",
 811                                     op->longName) - 1;
 812                                 if (op->shortName) {
 813                                         snprintf(err_buf+n, sizeof err_buf-n,
 814                                             " (-%c)\n", op->shortName);
 815                                 }
 816                         } else {
 817                                 snprintf(err_buf, sizeof err_buf, "%s%s: %s\n",
 818                                     am_server ? "on remote machine: " : "",
 819                                     poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 820                                     poptStrerror(opt));
 821                         }
 822                         return 0;
 823                 }
 824         }
 825
 826         if (am_sender < 0)
 827                 am_sender = 0;
 828
 829 #if !SUPPORT_LINKS
 830         if (preserve_links && !am_sender) {
 831                 snprintf(err_buf, sizeof err_buf,
 832                          "symlinks are not supported on this %s\n",
 833                          am_server ? "server" : "client");
 834                 return 0;
 835         }
 836 #endif
 837
 838 #if !SUPPORT_HARD_LINKS
 839         if (preserve_hard_links) {
 840                 snprintf(err_buf, sizeof err_buf,
 841                          "hard links are not supported on this %s\n",
 842                          am_server ? "server" : "client");
 843                 return 0;
 844         }
 845 #endif
 846
 847         if (write_batch && read_batch) {
 848                 snprintf(err_buf, sizeof err_buf,
 849                         "--write-batch and --read-batch can not be used together\n");
 850                 return 0;
 851         }
 852         if (write_batch || read_batch) {
 853                 if (dry_run) {
 854                         snprintf(err_buf, sizeof err_buf,
 855                                 "--%s-batch cannot be used with --dry_run (-n)\n",
 856                                 write_batch ? "write" : "read");
 857                         return 0;
 858                 }
 859                 if (am_server) {
 860                         rprintf(FINFO,
 861                                 "ignoring --%s-batch option sent to server\n",
 862                                 write_batch ? "write" : "read");
 863                         /* We don't actually exit_cleanup(), so that we can
 864                          * still service older version clients that still send
 865                          * batch args to server. */
 866                         read_batch = write_batch = 0;
 867                         batch_name = NULL;
 868                 }
 869         }
 870         if (read_batch && files_from) {
 871                 snprintf(err_buf, sizeof err_buf,
 872                         "--read-batch cannot be used with --files-from\n");
 873                 return 0;
 874         }
 875         if (batch_name && strlen(batch_name) > MAX_BATCH_NAME_LEN) {
 876                 snprintf(err_buf, sizeof err_buf,
 877                         "the batch-file name must be %d characters or less.\n",
 878                         MAX_BATCH_NAME_LEN);
 879                 return 0;
 880         }
 881
 882         if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
 883                 snprintf(err_buf, sizeof err_buf,
 884                          "the --temp-dir path is WAY too long.\n");
 885                 return 0;
 886         }
 887
 888         if (compare_dest + copy_dest + link_dest > 1) {
 889                 snprintf(err_buf, sizeof err_buf,
 890                         "You may not mix --compare-dest, --copy-dest, and --link-dest.\n");
 891                 return 0;
 892         }
 893
 894         if (archive_mode) {
 895                 if (!files_from)
 896                         recurse = -1; /* infinite recursion */
 897 #if SUPPORT_LINKS
 898                 preserve_links = 1;
 899 #endif
 900                 preserve_perms = 1;
 901                 preserve_times = 1;
 902                 preserve_gid = 1;
 903                 preserve_uid = 1;
 904                 preserve_devices = 1;
 905         }
 906
 907         if (recurse || list_only || files_from)
 908                 xfer_dirs |= 1;
 909
 910         if (relative_paths < 0)
 911                 relative_paths = files_from? 1 : 0;
 912
 913         if (!!delete_before + delete_during + delete_after > 1) {
 914                 snprintf(err_buf, sizeof err_buf,
 915                         "You may not combine multiple --delete-WHEN options.\n");
 916                 return 0;
 917         }
 918         if (!recurse) {
 919                 delete_before = delete_during = delete_after = 0;
 920                 delete_mode = delete_excluded = 0;
 921         } else if (delete_before || delete_during || delete_after)
 922                 delete_mode = 1;
 923         else if (delete_mode || delete_excluded)
 924                 delete_mode = delete_before = 1;
 925
 926         *argv = poptGetArgs(pc);
 927         *argc = count_args(*argv);
 928
 929         if (sanitize_paths) {
 930                 int i;
 931                 for (i = *argc; i-- > 0; )
 932                         (*argv)[i] = sanitize_path(NULL, (*argv)[i], "", 0);
 933                 if (tmpdir)
 934                         tmpdir = sanitize_path(NULL, tmpdir, NULL, 0);
 935                 if (partial_dir)
 936                         partial_dir = sanitize_path(NULL, partial_dir, NULL, 0);
 937                 if (backup_dir)
 938                         backup_dir = sanitize_path(NULL, backup_dir, NULL, 0);
 939                 if (files_from)
 940                         files_from = sanitize_path(NULL, files_from, NULL, 0);
 941         }
 942         if (server_filter_list.head && !am_sender) {
 943                 struct filter_list_struct *elp = &server_filter_list;
 944                 int i;
 945                 if (tmpdir) {
 946                         clean_fname(tmpdir, 1);
 947                         if (check_filter(elp, tmpdir, 1) < 0)
 948                                 goto options_rejected;
 949                 }
 950                 if (partial_dir) {
 951                         clean_fname(partial_dir, 1);
 952                         if (check_filter(elp, partial_dir, 1) < 0)
 953                                 goto options_rejected;
 954                 }
 955                 for (i = 0; i < basis_dir_cnt; i++) {
 956                         clean_fname(basis_dir[i], 1);
 957                         if (check_filter(elp, basis_dir[i], 1) < 0)
 958                                 goto options_rejected;
 959                 }
 960                 if (backup_dir) {
 961                         clean_fname(backup_dir, 1);
 962                         if (check_filter(elp, backup_dir, 1) < 0)
 963                                 goto options_rejected;
 964                 }
 965         }
 966         if (server_filter_list.head && files_from) {
 967                 clean_fname(files_from, 1);
 968                 if (check_filter(&server_filter_list, files_from, 0) < 0) {
 969                     options_rejected:
 970                         snprintf(err_buf, sizeof err_buf,
 971                             "Your options have been rejected by the server.\n");
 972                         return 0;
 973                 }
 974         }
 975
 976         if (!backup_suffix)
 977                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
 978         backup_suffix_len = strlen(backup_suffix);
 979         if (strchr(backup_suffix, '/') != NULL) {
 980                 snprintf(err_buf, sizeof err_buf,
 981                         "--suffix cannot contain slashes: %s\n",
 982                         backup_suffix);
 983                 return 0;
 984         }
 985         if (backup_dir) {
 986                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
 987                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
 988                 if (backup_dir_remainder < 32) {
 989                         snprintf(err_buf, sizeof err_buf,
 990                                 "the --backup-dir path is WAY too long.\n");
 991                         return 0;
 992                 }
 993                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
 994                         backup_dir_buf[backup_dir_len++] = '/';
 995                         backup_dir_buf[backup_dir_len] = '\0';
 996                 }
 997                 if (verbose > 1 && !am_sender)
 998                         rprintf(FINFO, "backup_dir is %s\n", backup_dir_buf);
 999         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
1000                 snprintf(err_buf, sizeof err_buf,
1001                         "--suffix cannot be a null string without --backup-dir\n");
1002                 return 0;
1003         }
1004
1005         if (do_progress && !verbose)
1006                 verbose = 1;
1007
1008         if (daemon_bwlimit && (!bwlimit || bwlimit > daemon_bwlimit))
1009                 bwlimit = daemon_bwlimit;
1010         if (bwlimit) {
1011                 bwlimit_writemax = (size_t)bwlimit * 128;
1012                 if (bwlimit_writemax < 512)
1013                         bwlimit_writemax = 512;
1014         }
1015
1016         if (delay_updates && !partial_dir)
1017                 partial_dir = ".~tmp~";
1018
1019         if (inplace) {
1020 #if HAVE_FTRUNCATE
1021                 if (partial_dir) {
1022                         snprintf(err_buf, sizeof err_buf,
1023                                  "--inplace cannot be used with --%s\n",
1024                                  delay_updates ? "delay-updates" : "partial-dir");
1025                         return 0;
1026                 }
1027                 keep_partial = 0;
1028 #else
1029                 snprintf(err_buf, sizeof err_buf,
1030                          "--inplace is not supported on this %s\n",
1031                          am_server ? "server" : "client");
1032                 return 0;
1033 #endif
1034         } else {
1035                 if (keep_partial && !partial_dir)
1036                         partial_dir = getenv("RSYNC_PARTIAL_DIR");
1037                 if (partial_dir) {
1038                         if (!*partial_dir || strcmp(partial_dir, ".") == 0)
1039                                 partial_dir = NULL;
1040                         else if (*partial_dir != '/') {
1041                                 add_filter(&filter_list, partial_dir,
1042                                     MATCHFLG_NO_PREFIXES|MATCHFLG_DIRECTORY, 0);
1043                         }
1044                         keep_partial = 1;
1045                 }
1046         }
1047
1048         if (files_from) {
1049                 char *colon;
1050                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
1051                         usage(FERROR);
1052                         exit_cleanup(RERR_SYNTAX);
1053                 }
1054                 if (strcmp(files_from, "-") == 0) {
1055                         filesfrom_fd = 0;
1056                         if (am_server)
1057                                 remote_filesfrom_file = "-";
1058                 }
1059                 else if ((colon = find_colon(files_from)) != 0) {
1060                         if (am_server) {
1061                                 usage(FERROR);
1062                                 exit_cleanup(RERR_SYNTAX);
1063                         }
1064                         remote_filesfrom_file = colon+1 + (colon[1] == ':');
1065                         if (strcmp(remote_filesfrom_file, "-") == 0) {
1066                                 snprintf(err_buf, sizeof err_buf,
1067                                         "Invalid --files-from remote filename\n");
1068                                 return 0;
1069                         }
1070                 } else {
1071                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
1072                         if (filesfrom_fd < 0) {
1073                                 snprintf(err_buf, sizeof err_buf,
1074                                         "failed to open files-from file %s: %s\n",
1075                                         files_from, strerror(errno));
1076                                 return 0;
1077                         }
1078                 }
1079         }
1080
1081         return 1;
1082 }
1083
1084
1085 /**
1086  * Construct a filtered list of options to pass through from the
1087  * client to the server.
1088  *
1089  * This involves setting options that will tell the server how to
1090  * behave, and also filtering out options that are processed only
1091  * locally.
1092  **/
1093 void server_options(char **args,int *argc)
1094 {
1095         static char argstr[50+MAX_BASIS_DIRS*2];
1096         int ac = *argc;
1097         char *arg;
1098
1099         int i, x;
1100
1101         if (blocking_io == -1)
1102                 blocking_io = 0;
1103
1104         args[ac++] = "--server";
1105
1106         if (daemon_over_rsh) {
1107                 args[ac++] = "--daemon";
1108                 *argc = ac;
1109                 /* if we're passing --daemon, we're done */
1110                 return;
1111         }
1112
1113         if (!am_sender)
1114                 args[ac++] = "--sender";
1115
1116         x = 1;
1117         argstr[0] = '-';
1118         for (i = 0; i < verbose; i++)
1119                 argstr[x++] = 'v';
1120
1121         /* the -q option is intentionally left out */
1122         if (make_backups)
1123                 argstr[x++] = 'b';
1124         if (update_only)
1125                 argstr[x++] = 'u';
1126         if (dry_run)
1127                 argstr[x++] = 'n';
1128         if (preserve_links)
1129                 argstr[x++] = 'l';
1130         if (copy_links)
1131                 argstr[x++] = 'L';
1132         if (xfer_dirs > 1)
1133                 argstr[x++] = 'd';
1134         if (keep_dirlinks && am_sender)
1135                 argstr[x++] = 'K';
1136
1137         if (whole_file > 0)
1138                 argstr[x++] = 'W';
1139         /* We don't need to send --no-whole-file, because it's the
1140          * default for remote transfers, and in any case old versions
1141          * of rsync will not understand it. */
1142
1143         if (preserve_hard_links)
1144                 argstr[x++] = 'H';
1145         if (preserve_uid)
1146                 argstr[x++] = 'o';
1147         if (preserve_gid)
1148                 argstr[x++] = 'g';
1149         if (preserve_devices)
1150                 argstr[x++] = 'D';
1151         if (preserve_times)
1152                 argstr[x++] = 't';
1153         if (omit_dir_times && am_sender)
1154                 argstr[x++] = 'O';
1155         if (preserve_perms)
1156                 argstr[x++] = 'p';
1157         if (recurse < 0)
1158                 argstr[x++] = 'r';
1159         if (always_checksum)
1160                 argstr[x++] = 'c';
1161         if (cvs_exclude)
1162                 argstr[x++] = 'C';
1163         if (ignore_times)
1164                 argstr[x++] = 'I';
1165         if (relative_paths)
1166                 argstr[x++] = 'R';
1167         if (one_file_system)
1168                 argstr[x++] = 'x';
1169         if (sparse_files)
1170                 argstr[x++] = 'S';
1171         if (do_compression)
1172                 argstr[x++] = 'z';
1173
1174         /* This is a complete hack - blame Rusty.  FIXME!
1175          * This hack is only needed for older rsync versions that
1176          * don't understand the --list-only option. */
1177         if (list_only == 1 && recurse >= 0)
1178                 argstr[x++] = 'r';
1179
1180         argstr[x] = 0;
1181
1182         if (x != 1)
1183                 args[ac++] = argstr;
1184
1185         if (list_only > 1)
1186                 args[ac++] = "--list-only";
1187
1188         if (block_size) {
1189                 if (asprintf(&arg, "-B%lu", block_size) < 0)
1190                         goto oom;
1191                 args[ac++] = arg;
1192         }
1193
1194         if (max_delete && am_sender) {
1195                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
1196                         goto oom;
1197                 args[ac++] = arg;
1198         }
1199
1200         if (max_size && am_sender) {
1201                 args[ac++] = "--max-size";
1202                 args[ac++] = max_size_arg;
1203         }
1204
1205         if (io_timeout) {
1206                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
1207                         goto oom;
1208                 args[ac++] = arg;
1209         }
1210
1211         if (bwlimit) {
1212                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
1213                         goto oom;
1214                 args[ac++] = arg;
1215         }
1216
1217         if (backup_dir) {
1218                 args[ac++] = "--backup-dir";
1219                 args[ac++] = backup_dir;
1220         }
1221
1222         /* Only send --suffix if it specifies a non-default value. */
1223         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1224                 /* We use the following syntax to avoid weirdness with '~'. */
1225                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1226                         goto oom;
1227                 args[ac++] = arg;
1228         }
1229
1230         if (am_sender) {
1231                 if (delete_excluded)
1232                         args[ac++] = "--delete-excluded";
1233                 else if (delete_before == 1 || delete_after)
1234                         args[ac++] = "--delete";
1235                 if (delete_before > 1)
1236                         args[ac++] = "--delete-before";
1237                 if (delete_during)
1238                         args[ac++] = "--delete-during";
1239                 if (delete_after)
1240                         args[ac++] = "--delete-after";
1241                 if (force_delete)
1242                         args[ac++] = "--force";
1243         }
1244
1245         if (size_only)
1246                 args[ac++] = "--size-only";
1247
1248         if (modify_window_set) {
1249                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1250                         goto oom;
1251                 args[ac++] = arg;
1252         }
1253
1254         if (checksum_seed) {
1255                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1256                         goto oom;
1257                 args[ac++] = arg;
1258         }
1259
1260         if (partial_dir && am_sender) {
1261                 args[ac++] = "--partial-dir";
1262                 args[ac++] = partial_dir;
1263                 if (delay_updates)
1264                         args[ac++] = "--delay-updates";
1265         } else if (keep_partial)
1266                 args[ac++] = "--partial";
1267
1268         if (ignore_errors)
1269                 args[ac++] = "--ignore-errors";
1270
1271         if (copy_unsafe_links)
1272                 args[ac++] = "--copy-unsafe-links";
1273
1274         if (safe_symlinks)
1275                 args[ac++] = "--safe-links";
1276
1277         if (numeric_ids)
1278                 args[ac++] = "--numeric-ids";
1279
1280         if (only_existing && am_sender)
1281                 args[ac++] = "--existing";
1282
1283         if (opt_ignore_existing && am_sender)
1284                 args[ac++] = "--ignore-existing";
1285
1286         if (inplace)
1287                 args[ac++] = "--inplace";
1288
1289         if (tmpdir) {
1290                 args[ac++] = "--temp-dir";
1291                 args[ac++] = tmpdir;
1292         }
1293
1294         if (basis_dir[0] && am_sender) {
1295                 /* the server only needs this option if it is not the sender,
1296                  *   and it may be an older version that doesn't know this
1297                  *   option, so don't send it if client is the sender.
1298                  */
1299                 int i;
1300                 for (i = 0; i < basis_dir_cnt; i++) {
1301                         args[ac++] = dest_option;
1302                         args[ac++] = basis_dir[i];
1303                 }
1304         }
1305
1306         if (files_from && (!am_sender || remote_filesfrom_file)) {
1307                 if (remote_filesfrom_file) {
1308                         args[ac++] = "--files-from";
1309                         args[ac++] = remote_filesfrom_file;
1310                         if (eol_nulls)
1311                                 args[ac++] = "--from0";
1312                 } else {
1313                         args[ac++] = "--files-from=-";
1314                         args[ac++] = "--from0";
1315                 }
1316                 if (!relative_paths)
1317                         args[ac++] = "--no-relative";
1318         }
1319         if (!implied_dirs && !am_sender)
1320                 args[ac++] = "--no-implied-dirs";
1321
1322         *argc = ac;
1323         return;
1324
1325     oom:
1326         out_of_memory("server_options");
1327 }
1328
1329 /**
1330  * Return the position of a ':' IF it is not part of a filename (i.e. as
1331  * long as it doesn't occur after a slash.
1332  */
1333 char *find_colon(char *s)
1334 {
1335         char *p, *p2;
1336
1337         p = strchr(s,':');
1338         if (!p)
1339                 return NULL;
1340
1341         /* now check to see if there is a / in the string before the : - if there is then
1342            discard the colon on the assumption that the : is part of a filename */
1343         p2 = strchr(s,'/');
1344         if (p2 && p2 < p)
1345                 return NULL;
1346
1347         return p;
1348 }