options.c

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