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