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