options.c

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