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 log_before_transfer = 0;
 154 int log_format_has_i = 0;
 155 int log_format_has_o_or_i = 0;
 156 int always_checksum = 0;
 157 int list_only = 0;
 158
 159 #define MAX_BATCH_NAME_LEN 256  /* Must be less than MAXPATHLEN-13 */
 160 char *batch_name = NULL;
 161
 162 static int daemon_opt;   /* sets am_daemon after option error-reporting */
 163 static int F_option_cnt = 0;
 164 static int modify_window_set;
 165 static int itemize_changes = 0;
 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,"     --address=ADDRESS       bind address for outgoing socket to daemon\n");
 336   rprintf(F,"     --port=PORT             specify double-colon alternate port number\n");
 337   rprintf(F,"     --blocking-io           use blocking I/O for the remote shell\n");
 338   rprintf(F,"     --no-blocking-io        turn off blocking I/O when it is the default\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     log file-transfers using 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,"     --read-batch=FILE       read a batched update from FILE\n");
 349   rprintf(F,"     --protocol=NUM          force an older protocol version to be used\n");
 350 #ifdef INET6
 351   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 352   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 353 #endif
 354   rprintf(F," -h, --help                  show this help screen\n");
 355
 356   rprintf(F,"\nUse \"rsync --daemon --help\" to see the daemon-mode command-line options.\n");
 357   rprintf(F,"Please see the rsync(1) and rsyncd.conf(5) man pages for full documentation.\n");
 358   rprintf(F,"See http://rsync.samba.org/ for updates, bug reports, and answers\n");
 359 }
 360
 361 enum {OPT_VERSION = 1000, OPT_DAEMON, OPT_SENDER, OPT_EXCLUDE, OPT_EXCLUDE_FROM,
 362       OPT_FILTER, OPT_COMPARE_DEST, OPT_COPY_DEST, OPT_LINK_DEST,
 363       OPT_INCLUDE, OPT_INCLUDE_FROM, OPT_MODIFY_WINDOW,
 364       OPT_READ_BATCH, OPT_WRITE_BATCH, OPT_TIMEOUT, OPT_MAX_SIZE,
 365       OPT_REFUSED_BASE = 9000};
 366
 367 static struct poptOption long_options[] = {
 368   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 369   {"version",          0,  POPT_ARG_NONE,   0, OPT_VERSION, 0, 0},
 370   {"suffix",           0,  POPT_ARG_STRING, &backup_suffix, 0, 0, 0 },
 371   {"rsync-path",       0,  POPT_ARG_STRING, &rsync_path, 0, 0, 0 },
 372   {"password-file",    0,  POPT_ARG_STRING, &password_file, 0, 0, 0 },
 373   {"ignore-times",    'I', POPT_ARG_NONE,   &ignore_times, 0, 0, 0 },
 374   {"size-only",        0,  POPT_ARG_NONE,   &size_only, 0, 0, 0 },
 375   {"modify-window",    0,  POPT_ARG_INT,    &modify_window, OPT_MODIFY_WINDOW, 0, 0 },
 376   {"one-file-system", 'x', POPT_ARG_NONE,   &one_file_system, 0, 0, 0 },
 377   {"existing",         0,  POPT_ARG_NONE,   &only_existing, 0, 0, 0 },
 378   {"ignore-existing",  0,  POPT_ARG_NONE,   &opt_ignore_existing, 0, 0, 0 },
 379   {"del",              0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 380   {"delete",           0,  POPT_ARG_NONE,   &delete_mode, 0, 0, 0 },
 381   {"delete-before",    0,  POPT_ARG_VAL,    &delete_before, 2, 0, 0 },
 382   {"delete-during",    0,  POPT_ARG_NONE,   &delete_during, 0, 0, 0 },
 383   {"delete-after",     0,  POPT_ARG_NONE,   &delete_after, 0, 0, 0 },
 384   {"delete-excluded",  0,  POPT_ARG_NONE,   &delete_excluded, 0, 0, 0 },
 385   {"remove-sent-files",0,  POPT_ARG_NONE,   &remove_sent_files, 0, 0, 0 },
 386   {"force",            0,  POPT_ARG_NONE,   &force_delete, 0, 0, 0 },
 387   {"numeric-ids",      0,  POPT_ARG_NONE,   &numeric_ids, 0, 0, 0 },
 388   {"filter",          'f', POPT_ARG_STRING, 0, OPT_FILTER, 0, 0 },
 389   {"exclude",          0,  POPT_ARG_STRING, 0, OPT_EXCLUDE, 0, 0 },
 390   {"include",          0,  POPT_ARG_STRING, 0, OPT_INCLUDE, 0, 0 },
 391   {"exclude-from",     0,  POPT_ARG_STRING, 0, OPT_EXCLUDE_FROM, 0, 0 },
 392   {"include-from",     0,  POPT_ARG_STRING, 0, OPT_INCLUDE_FROM, 0, 0 },
 393   {"safe-links",       0,  POPT_ARG_NONE,   &safe_symlinks, 0, 0, 0 },
 394   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 395   {"backup",          'b', POPT_ARG_NONE,   &make_backups, 0, 0, 0 },
 396   {"dry-run",         'n', POPT_ARG_NONE,   &dry_run, 0, 0, 0 },
 397   {"sparse",          'S', POPT_ARG_NONE,   &sparse_files, 0, 0, 0 },
 398   {"cvs-exclude",     'C', POPT_ARG_NONE,   &cvs_exclude, 0, 0, 0 },
 399   {"update",          'u', POPT_ARG_NONE,   &update_only, 0, 0, 0 },
 400   {"inplace",          0,  POPT_ARG_NONE,   &inplace, 0, 0, 0 },
 401   {"dirs",            'd', POPT_ARG_VAL,    &xfer_dirs, 2, 0, 0 },
 402   {"links",           'l', POPT_ARG_NONE,   &preserve_links, 0, 0, 0 },
 403   {"copy-links",      'L', POPT_ARG_NONE,   &copy_links, 0, 0, 0 },
 404   {"keep-dirlinks",   'K', POPT_ARG_NONE,   &keep_dirlinks, 0, 0, 0 },
 405   {"whole-file",      'W', POPT_ARG_VAL,    &whole_file, 1, 0, 0 },
 406   {"no-whole-file",    0,  POPT_ARG_VAL,    &whole_file, 0, 0, 0 },
 407   {"copy-unsafe-links",0,  POPT_ARG_NONE,   &copy_unsafe_links, 0, 0, 0 },
 408   {"perms",           'p', POPT_ARG_NONE,   &preserve_perms, 0, 0, 0 },
 409   {"owner",           'o', POPT_ARG_NONE,   &preserve_uid, 0, 0, 0 },
 410   {"group",           'g', POPT_ARG_NONE,   &preserve_gid, 0, 0, 0 },
 411   {"devices",         'D', POPT_ARG_NONE,   &preserve_devices, 0, 0, 0 },
 412   {"times",           't', POPT_ARG_NONE,   &preserve_times, 0, 0, 0 },
 413   {"omit-dir-times",  'O', POPT_ARG_VAL,    &omit_dir_times, 2, 0, 0 },
 414   {"checksum",        'c', POPT_ARG_NONE,   &always_checksum, 0, 0, 0 },
 415   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 416   {"quiet",           'q', POPT_ARG_NONE,   0, 'q', 0, 0 },
 417   {"archive",         'a', POPT_ARG_NONE,   &archive_mode, 0, 0, 0 },
 418   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 419   {"sender",           0,  POPT_ARG_NONE,   0, OPT_SENDER, 0, 0 },
 420   {"recursive",       'r', POPT_ARG_NONE,   &recurse, 0, 0, 0 },
 421   {"list-only",        0,  POPT_ARG_VAL,    &list_only, 2, 0, 0 },
 422   {"relative",        'R', POPT_ARG_VAL,    &relative_paths, 1, 0, 0 },
 423   {"no-relative",      0,  POPT_ARG_VAL,    &relative_paths, 0, 0, 0 },
 424   {"rsh",             'e', POPT_ARG_STRING, &shell_cmd, 0, 0, 0 },
 425   {"block-size",      'B', POPT_ARG_LONG,   &block_size, 0, 0, 0 },
 426   {"max-delete",       0,  POPT_ARG_INT,    &max_delete, 0, 0, 0 },
 427   {"max-size",         0,  POPT_ARG_STRING, &max_size_arg,  OPT_MAX_SIZE, 0, 0 },
 428   {"timeout",          0,  POPT_ARG_INT,    &io_timeout, OPT_TIMEOUT, 0, 0 },
 429   {"temp-dir",        'T', POPT_ARG_STRING, &tmpdir, 0, 0, 0 },
 430   {"compare-dest",     0,  POPT_ARG_STRING, 0, OPT_COMPARE_DEST, 0, 0 },
 431   {"copy-dest",        0,  POPT_ARG_STRING, 0, OPT_COPY_DEST, 0, 0 },
 432   {"link-dest",        0,  POPT_ARG_STRING, 0, OPT_LINK_DEST, 0, 0 },
 433   {"fuzzy",           'y', POPT_ARG_NONE,   &fuzzy_basis, 0, 0, 0 },
 434   /* TODO: Should this take an optional int giving the compression level? */
 435   {"compress",        'z', POPT_ARG_NONE,   &do_compression, 0, 0, 0 },
 436   {"stats",            0,  POPT_ARG_NONE,   &do_stats, 0, 0, 0 },
 437   {"progress",         0,  POPT_ARG_NONE,   &do_progress, 0, 0, 0 },
 438   {"partial",          0,  POPT_ARG_NONE,   &keep_partial, 0, 0, 0 },
 439   {"partial-dir",      0,  POPT_ARG_STRING, &partial_dir, 0, 0, 0 },
 440   {"delay-updates",    0,  POPT_ARG_NONE,   &delay_updates, 0, 0, 0 },
 441   {"ignore-errors",    0,  POPT_ARG_NONE,   &ignore_errors, 0, 0, 0 },
 442   {"blocking-io",      0,  POPT_ARG_VAL,    &blocking_io, 1, 0, 0 },
 443   {"no-blocking-io",   0,  POPT_ARG_VAL,    &blocking_io, 0, 0, 0 },
 444   {0,                 'F', POPT_ARG_NONE,   0, 'F', 0, 0 },
 445   {0,                 'P', POPT_ARG_NONE,   0, 'P', 0, 0 },
 446   {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
 447   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 448   {"log-format",       0,  POPT_ARG_STRING, &log_format, 0, 0, 0 },
 449   {"itemize-changes", 'i', POPT_ARG_NONE,   &itemize_changes, 0, 0, 0 },
 450   {"bwlimit",          0,  POPT_ARG_INT,    &bwlimit, 0, 0, 0 },
 451   {"backup-dir",       0,  POPT_ARG_STRING, &backup_dir, 0, 0, 0 },
 452   {"hard-links",      'H', POPT_ARG_NONE,   &preserve_hard_links, 0, 0, 0 },
 453   {"read-batch",       0,  POPT_ARG_STRING, &batch_name, OPT_READ_BATCH, 0, 0 },
 454   {"write-batch",      0,  POPT_ARG_STRING, &batch_name, OPT_WRITE_BATCH, 0, 0 },
 455   {"files-from",       0,  POPT_ARG_STRING, &files_from, 0, 0, 0 },
 456   {"from0",           '0', POPT_ARG_NONE,   &eol_nulls, 0, 0, 0},
 457   {"no-implied-dirs",  0,  POPT_ARG_VAL,    &implied_dirs, 0, 0, 0 },
 458   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 459   {"checksum-seed",    0,  POPT_ARG_INT,    &checksum_seed, 0, 0, 0 },
 460 #ifdef INET6
 461   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 462   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 463 #endif
 464   /* All these options switch us into daemon-mode option-parsing. */
 465   {"config",           0,  POPT_ARG_STRING, 0, OPT_DAEMON, 0, 0 },
 466   {"daemon",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 467   {"detach",           0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 468   {"no-detach",        0,  POPT_ARG_NONE,   0, OPT_DAEMON, 0, 0 },
 469   {0,0,0,0, 0, 0, 0}
 470 };
 471
 472 static void daemon_usage(enum logcode F)
 473 {
 474   print_rsync_version(F);
 475
 476   rprintf(F,"\nUsage: rsync --daemon [OPTION]...\n");
 477   rprintf(F,"     --address=ADDRESS       bind to the specified address\n");
 478   rprintf(F,"     --bwlimit=KBPS          limit I/O bandwidth; KBytes per second\n");
 479   rprintf(F,"     --config=FILE           specify alternate rsyncd.conf file\n");
 480   rprintf(F,"     --no-detach             do not detach from the parent\n");
 481   rprintf(F,"     --port=PORT             listen on alternate port number\n");
 482   rprintf(F," -v, --verbose               increase verbosity\n");
 483 #ifdef INET6
 484   rprintf(F," -4, --ipv4                  prefer IPv4\n");
 485   rprintf(F," -6, --ipv6                  prefer IPv6\n");
 486 #endif
 487   rprintf(F," -h, --help                  show this help screen\n");
 488
 489   rprintf(F,"\nIf you were not trying to invoke rsync as a daemon, avoid using any of the\n");
 490   rprintf(F,"daemon-specific rsync options.  See also the rsyncd.conf(5) man page.\n");
 491 }
 492
 493 static struct poptOption long_daemon_options[] = {
 494   /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
 495   {"address",          0,  POPT_ARG_STRING, &bind_address, 0, 0, 0 },
 496   {"bwlimit",          0,  POPT_ARG_INT,    &daemon_bwlimit, 0, 0, 0 },
 497   {"config",           0,  POPT_ARG_STRING, &config_file, 0, 0, 0 },
 498   {"daemon",           0,  POPT_ARG_NONE,   &daemon_opt, 0, 0, 0 },
 499 #ifdef INET6
 500   {"ipv4",            '4', POPT_ARG_VAL,    &default_af_hint, AF_INET, 0, 0 },
 501   {"ipv6",            '6', POPT_ARG_VAL,    &default_af_hint, AF_INET6, 0, 0 },
 502 #endif
 503   {"detach",           0,  POPT_ARG_VAL,    &no_detach, 0, 0, 0 },
 504   {"no-detach",        0,  POPT_ARG_VAL,    &no_detach, 1, 0, 0 },
 505   {"port",             0,  POPT_ARG_INT,    &rsync_port, 0, 0, 0 },
 506   {"protocol",         0,  POPT_ARG_INT,    &protocol_version, 0, 0, 0 },
 507   {"server",           0,  POPT_ARG_NONE,   &am_server, 0, 0, 0 },
 508   {"verbose",         'v', POPT_ARG_NONE,   0, 'v', 0, 0 },
 509   {"help",            'h', POPT_ARG_NONE,   0, 'h', 0, 0 },
 510   {0,0,0,0, 0, 0, 0}
 511 };
 512
 513
 514 static char err_buf[200];
 515
 516
 517 /**
 518  * Store the option error message, if any, so that we can log the
 519  * connection attempt (which requires parsing the options), and then
 520  * show the error later on.
 521  **/
 522 void option_error(void)
 523 {
 524         if (!err_buf[0]) {
 525                 strcpy(err_buf, "Error parsing options: "
 526                     "option may be supported on client but not on server?\n");
 527         }
 528
 529         rprintf(FERROR, RSYNC_NAME ": %s", err_buf);
 530 }
 531
 532
 533 /**
 534  * Tweak the option table to disable all options that the rsyncd.conf
 535  * file has told us to refuse.
 536  **/
 537 static void set_refuse_options(char *bp)
 538 {
 539         struct poptOption *op;
 540         char *cp, shortname[2];
 541         int is_wild, found_match;
 542
 543         shortname[1] = '\0';
 544
 545         while (1) {
 546                 while (*bp == ' ') bp++;
 547                 if (!*bp)
 548                         break;
 549                 if ((cp = strchr(bp, ' ')) != NULL)
 550                         *cp= '\0';
 551                 is_wild = strpbrk(bp, "*?[") != NULL;
 552                 found_match = 0;
 553                 for (op = long_options; ; op++) {
 554                         *shortname = op->shortName;
 555                         if (!op->longName && !*shortname)
 556                                 break;
 557                         if ((op->longName && wildmatch(bp, op->longName))
 558                             || (*shortname && wildmatch(bp, shortname))) {
 559                                 if (op->argInfo == POPT_ARG_VAL)
 560                                         op->argInfo = POPT_ARG_NONE;
 561                                 op->val = (op - long_options) + OPT_REFUSED_BASE;
 562                                 found_match = 1;
 563                                 /* These flags are set to let us easily check
 564                                  * an implied option later in the code. */
 565                                 switch (*shortname) {
 566                                 case 'r': case 'd': case 'l': case 'p':
 567                                 case 't': case 'g': case 'o': case 'D':
 568                                         refused_archive_part = op->val;
 569                                         break;
 570                                 case '\0':
 571                                         if (wildmatch("delete", op->longName))
 572                                                 refused_delete = op->val;
 573                                         else if (wildmatch("delete-before", op->longName))
 574                                                 refused_delete_before = op->val;
 575                                         else if (wildmatch("partial", op->longName))
 576                                                 refused_partial = op->val;
 577                                         else if (wildmatch("progress", op->longName))
 578                                                 refused_progress = op->val;
 579                                         break;
 580                                 }
 581                                 if (!is_wild)
 582                                         break;
 583                         }
 584                 }
 585                 if (!found_match) {
 586                         rprintf(FLOG, "No match for refuse-options string \"%s\"\n",
 587                                 bp);
 588                 }
 589                 if (!cp)
 590                         break;
 591                 *cp = ' ';
 592                 bp = cp + 1;
 593         }
 594
 595         for (op = long_options; ; op++) {
 596                 *shortname = op->shortName;
 597                 if (!op->longName && !*shortname)
 598                         break;
 599                 if (op->val == OPT_DAEMON) {
 600                         if (op->argInfo == POPT_ARG_VAL)
 601                                 op->argInfo = POPT_ARG_NONE;
 602                         op->val = (op - long_options) + OPT_REFUSED_BASE;
 603                 }
 604         }
 605 }
 606
 607
 608 static int count_args(const char **argv)
 609 {
 610         int i = 0;
 611
 612         if (argv) {
 613                 while (argv[i] != NULL)
 614                         i++;
 615         }
 616
 617         return i;
 618 }
 619
 620
 621 static void create_refuse_error(int which)
 622 {
 623         /* The "which" value is the index + OPT_REFUSED_BASE. */
 624         struct poptOption *op = &long_options[which - OPT_REFUSED_BASE];
 625         int n = snprintf(err_buf, sizeof err_buf,
 626                          "The server is configured to refuse --%s\n",
 627                          op->longName) - 1;
 628         if (op->shortName) {
 629                 snprintf(err_buf + n, sizeof err_buf - n,
 630                          " (-%c)\n", op->shortName);
 631         }
 632 }
 633
 634
 635 /**
 636  * Process command line arguments.  Called on both local and remote.
 637  *
 638  * @retval 1 if all options are OK; with globals set to appropriate
 639  * values
 640  *
 641  * @retval 0 on error, with err_buf containing an explanation
 642  **/
 643 int parse_arguments(int *argc, const char ***argv, int frommain)
 644 {
 645         int opt;
 646         char *ref = lp_refuse_options(module_id);
 647         const char *arg;
 648         poptContext pc;
 649
 650         if (ref && *ref)
 651                 set_refuse_options(ref);
 652
 653         /* TODO: Call poptReadDefaultConfig; handle errors. */
 654
 655         /* The context leaks in case of an error, but if there's a
 656          * problem we always exit anyhow. */
 657         pc = poptGetContext(RSYNC_NAME, *argc, *argv, long_options, 0);
 658         poptReadDefaultConfig(pc, 0);
 659
 660         while ((opt = poptGetNextOpt(pc)) != -1) {
 661                 /* most options are handled automatically by popt;
 662                  * only special cases are returned and listed here. */
 663
 664                 switch (opt) {
 665                 case OPT_VERSION:
 666                         print_rsync_version(FINFO);
 667                         exit_cleanup(0);
 668
 669                 case OPT_DAEMON:
 670                         if (am_daemon) {
 671                                 strcpy(err_buf, "Attempt to hack rsync thwarted!\n");
 672                                 return 0;
 673                         }
 674                         poptFreeContext(pc);
 675                         pc = poptGetContext(RSYNC_NAME, *argc, *argv,
 676                                             long_daemon_options, 0);
 677                         while ((opt = poptGetNextOpt(pc)) != -1) {
 678                                 switch (opt) {
 679                                 case 'h':
 680                                         daemon_usage(FINFO);
 681                                         exit_cleanup(0);
 682
 683                                 case 'v':
 684                                         verbose++;
 685                                         break;
 686
 687                                 default:
 688                                         rprintf(FERROR,
 689                                             "rsync: %s: %s (in daemon mode)\n",
 690                                             poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 691                                             poptStrerror(opt));
 692                                         goto daemon_error;
 693                                 }
 694                         }
 695                         if (!daemon_opt) {
 696                                 rprintf(FERROR, "Daemon option(s) used without --daemon.\n");
 697                             daemon_error:
 698                                 rprintf(FERROR,
 699                                     "(Type \"rsync --daemon --help\" for assistance with daemon mode.)\n");
 700                                 exit_cleanup(RERR_SYNTAX);
 701                         }
 702                         *argv = poptGetArgs(pc);
 703                         *argc = count_args(*argv);
 704                         am_starting_up = 0;
 705                         daemon_opt = 0;
 706                         am_daemon = 1;
 707                         return 1;
 708
 709                 case OPT_MODIFY_WINDOW:
 710                         /* The value has already been set by popt, but
 711                          * we need to remember that we're using a
 712                          * non-default setting. */
 713                         modify_window_set = 1;
 714                         break;
 715
 716                 case OPT_FILTER:
 717                         parse_rule(&filter_list, poptGetOptArg(pc), 0, 0);
 718                         break;
 719
 720                 case OPT_EXCLUDE:
 721                         parse_rule(&filter_list, poptGetOptArg(pc),
 722                                    0, XFLG_OLD_PREFIXES);
 723                         break;
 724
 725                 case OPT_INCLUDE:
 726                         parse_rule(&filter_list, poptGetOptArg(pc),
 727                                    MATCHFLG_INCLUDE, XFLG_OLD_PREFIXES);
 728                         break;
 729
 730                 case OPT_EXCLUDE_FROM:
 731                 case OPT_INCLUDE_FROM:
 732                         arg = poptGetOptArg(pc);
 733                         if (sanitize_paths)
 734                                 arg = sanitize_path(NULL, arg, NULL, 0);
 735                         if (server_filter_list.head) {
 736                                 char *cp = (char *)arg;
 737                                 if (!*cp)
 738                                         goto options_rejected;
 739                                 clean_fname(cp, 1);
 740                                 if (check_filter(&server_filter_list, cp, 0) < 0)
 741                                         goto options_rejected;
 742                         }
 743                         parse_filter_file(&filter_list, arg,
 744                                 opt == OPT_INCLUDE_FROM ? MATCHFLG_INCLUDE : 0,
 745                                 XFLG_FATAL_ERRORS | XFLG_OLD_PREFIXES);
 746                         break;
 747
 748                 case 'h':
 749                         usage(FINFO);
 750                         exit_cleanup(0);
 751
 752                 case 'v':
 753                         verbose++;
 754                         break;
 755
 756                 case 'q':
 757                         if (frommain)
 758                                 quiet++;
 759                         break;
 760
 761                 case OPT_SENDER:
 762                         if (!am_server) {
 763                                 usage(FERROR);
 764                                 exit_cleanup(RERR_SYNTAX);
 765                         }
 766                         am_sender = 1;
 767                         break;
 768
 769                 case 'F':
 770                         switch (++F_option_cnt) {
 771                         case 1:
 772                                 parse_rule(&filter_list,": /.rsync-filter",0,0);
 773                                 break;
 774                         case 2:
 775                                 parse_rule(&filter_list,"- .rsync-filter",0,0);
 776                                 break;
 777                         }
 778                         break;
 779
 780                 case 'P':
 781                         if (refused_partial || refused_progress) {
 782                                 create_refuse_error(refused_partial
 783                                     ? refused_partial : refused_progress);
 784                                 return 0;
 785                         }
 786                         do_progress = 1;
 787                         keep_partial = 1;
 788                         break;
 789
 790                 case OPT_WRITE_BATCH:
 791                         /* batch_name is already set */
 792                         write_batch = 1;
 793                         break;
 794
 795                 case OPT_READ_BATCH:
 796                         /* batch_name is already set */
 797                         read_batch = 1;
 798                         break;
 799
 800                 case OPT_MAX_SIZE:
 801                         for (arg = max_size_arg; isdigit(*(uchar*)arg); arg++) {}
 802                         if (*arg == '.')
 803                                 for (arg++; isdigit(*(uchar*)arg); arg++) {}
 804                         switch (*arg) {
 805                         case 'k': case 'K':
 806                                 max_size = atof(max_size_arg) * 1024;
 807                                 break;
 808                         case 'm': case 'M':
 809                                 max_size = atof(max_size_arg) * 1024*1024;
 810                                 break;
 811                         case 'g': case 'G':
 812                                 max_size = atof(max_size_arg) * 1024*1024*1024;
 813                                 break;
 814                         case '\0':
 815                                 max_size = atof(max_size_arg);
 816                                 break;
 817                         default:
 818                                 max_size = 0;
 819                                 break;
 820                         }
 821                         if (max_size <= 0) {
 822                                 snprintf(err_buf, sizeof err_buf,
 823                                         "--max-size value is invalid: %s\n",
 824                                         max_size_arg);
 825                                 return 0;
 826                         }
 827                         break;
 828
 829                 case OPT_TIMEOUT:
 830                         if (io_timeout && io_timeout < select_timeout)
 831                                 select_timeout = io_timeout;
 832                         break;
 833
 834                 case OPT_LINK_DEST:
 835 #ifdef HAVE_LINK
 836                         link_dest = 1;
 837                         dest_option = "--link-dest";
 838                         goto set_dest_dir;
 839 #else
 840                         snprintf(err_buf, sizeof err_buf,
 841                                  "hard links are not supported on this %s\n",
 842                                  am_server ? "server" : "client");
 843                         return 0;
 844 #endif
 845
 846                 case OPT_COPY_DEST:
 847                         copy_dest = 1;
 848                         dest_option = "--copy-dest";
 849                         goto set_dest_dir;
 850
 851                 case OPT_COMPARE_DEST:
 852                         compare_dest = 1;
 853                         dest_option = "--compare-dest";
 854                 set_dest_dir:
 855                         if (basis_dir_cnt >= MAX_BASIS_DIRS) {
 856                                 snprintf(err_buf, sizeof err_buf,
 857                                         "ERROR: at most %d %s args may be specified\n",
 858                                         MAX_BASIS_DIRS, dest_option);
 859                                 return 0;
 860                         }
 861                         arg = poptGetOptArg(pc);
 862                         if (sanitize_paths)
 863                                 arg = sanitize_path(NULL, arg, NULL, 0);
 864                         basis_dir[basis_dir_cnt++] = (char *)arg;
 865                         break;
 866
 867                 default:
 868                         /* A large opt value means that set_refuse_options()
 869                          * turned this option off. */
 870                         if (opt >= OPT_REFUSED_BASE) {
 871                                 create_refuse_error(opt);
 872                                 return 0;
 873                         }
 874                         snprintf(err_buf, sizeof err_buf, "%s%s: %s\n",
 875                                  am_server ? "on remote machine: " : "",
 876                                  poptBadOption(pc, POPT_BADOPTION_NOALIAS),
 877                                  poptStrerror(opt));
 878                         return 0;
 879                 }
 880         }
 881
 882 #ifndef SUPPORT_LINKS
 883         if (preserve_links && !am_sender) {
 884                 snprintf(err_buf, sizeof err_buf,
 885                          "symlinks are not supported on this %s\n",
 886                          am_server ? "server" : "client");
 887                 return 0;
 888         }
 889 #endif
 890
 891 #ifndef SUPPORT_HARD_LINKS
 892         if (preserve_hard_links) {
 893                 snprintf(err_buf, sizeof err_buf,
 894                          "hard links are not supported on this %s\n",
 895                          am_server ? "server" : "client");
 896                 return 0;
 897         }
 898 #endif
 899
 900         if (write_batch && read_batch) {
 901                 snprintf(err_buf, sizeof err_buf,
 902                         "--write-batch and --read-batch can not be used together\n");
 903                 return 0;
 904         }
 905         if (write_batch || read_batch) {
 906                 if (am_server) {
 907                         rprintf(FINFO,
 908                                 "ignoring --%s-batch option sent to server\n",
 909                                 write_batch ? "write" : "read");
 910                         /* We don't actually exit_cleanup(), so that we can
 911                          * still service older version clients that still send
 912                          * batch args to server. */
 913                         read_batch = write_batch = 0;
 914                         batch_name = NULL;
 915                 } else if (dry_run)
 916                         write_batch = 0;
 917         }
 918         if (read_batch && files_from) {
 919                 snprintf(err_buf, sizeof err_buf,
 920                         "--read-batch cannot be used with --files-from\n");
 921                 return 0;
 922         }
 923         if (batch_name && strlen(batch_name) > MAX_BATCH_NAME_LEN) {
 924                 snprintf(err_buf, sizeof err_buf,
 925                         "the batch-file name must be %d characters or less.\n",
 926                         MAX_BATCH_NAME_LEN);
 927                 return 0;
 928         }
 929
 930         if (tmpdir && strlen(tmpdir) >= MAXPATHLEN - 10) {
 931                 snprintf(err_buf, sizeof err_buf,
 932                          "the --temp-dir path is WAY too long.\n");
 933                 return 0;
 934         }
 935
 936         if (compare_dest + copy_dest + link_dest > 1) {
 937                 snprintf(err_buf, sizeof err_buf,
 938                         "You may not mix --compare-dest, --copy-dest, and --link-dest.\n");
 939                 return 0;
 940         }
 941
 942         if (archive_mode) {
 943                 if (refused_archive_part) {
 944                         create_refuse_error(refused_archive_part);
 945                         return 0;
 946                 }
 947                 if (!files_from)
 948                         recurse = 1;
 949 #ifdef SUPPORT_LINKS
 950                 preserve_links = 1;
 951 #endif
 952                 preserve_perms = 1;
 953                 preserve_times = 1;
 954                 preserve_gid = 1;
 955                 preserve_uid = 1;
 956                 preserve_devices = 1;
 957         }
 958
 959         if (recurse || list_only || files_from)
 960                 xfer_dirs |= 1;
 961
 962         if (relative_paths < 0)
 963                 relative_paths = files_from? 1 : 0;
 964
 965         if (!!delete_before + delete_during + delete_after > 1) {
 966                 snprintf(err_buf, sizeof err_buf,
 967                         "You may not combine multiple --delete-WHEN options.\n");
 968                 return 0;
 969         }
 970         if (!recurse) {
 971                 delete_before = delete_during = delete_after = 0;
 972                 delete_mode = delete_excluded = 0;
 973         } else if (delete_before || delete_during || delete_after)
 974                 delete_mode = 1;
 975         else if (delete_mode || delete_excluded) {
 976                 if (refused_delete_before) {
 977                         create_refuse_error(refused_delete_before);
 978                         return 0;
 979                 }
 980                 delete_mode = delete_before = 1;
 981         }
 982
 983         if (delete_mode && refused_delete) {
 984                 create_refuse_error(refused_delete);
 985                 return 0;
 986         }
 987
 988         if (remove_sent_files) {
 989                 /* We only want to infer this refusal of --remove-sent-files
 990                  * via the refusal of "delete", not any of the "delete-FOO"
 991                  * options. */
 992                 if (refused_delete && am_sender) {
 993                         create_refuse_error(refused_delete);
 994                         return 0;
 995                 }
 996                 need_messages_from_generator = 1;
 997         }
 998
 999         *argv = poptGetArgs(pc);
1000         *argc = count_args(*argv);
1001
1002         if (sanitize_paths) {
1003                 int i;
1004                 for (i = *argc; i-- > 0; )
1005                         (*argv)[i] = sanitize_path(NULL, (*argv)[i], "", 0);
1006                 if (tmpdir)
1007                         tmpdir = sanitize_path(NULL, tmpdir, NULL, 0);
1008                 if (partial_dir)
1009                         partial_dir = sanitize_path(NULL, partial_dir, NULL, 0);
1010                 if (backup_dir)
1011                         backup_dir = sanitize_path(NULL, backup_dir, NULL, 0);
1012         }
1013         if (server_filter_list.head && !am_sender) {
1014                 struct filter_list_struct *elp = &server_filter_list;
1015                 int i;
1016                 if (tmpdir) {
1017                         if (!*tmpdir)
1018                                 goto options_rejected;
1019                         clean_fname(tmpdir, 1);
1020                         if (check_filter(elp, tmpdir, 1) < 0)
1021                                 goto options_rejected;
1022                 }
1023                 if (partial_dir && *partial_dir) {
1024                         clean_fname(partial_dir, 1);
1025                         if (check_filter(elp, partial_dir, 1) < 0)
1026                                 goto options_rejected;
1027                 }
1028                 for (i = 0; i < basis_dir_cnt; i++) {
1029                         if (!*basis_dir[i])
1030                                 goto options_rejected;
1031                         clean_fname(basis_dir[i], 1);
1032                         if (check_filter(elp, basis_dir[i], 1) < 0)
1033                                 goto options_rejected;
1034                 }
1035                 if (backup_dir) {
1036                         if (!*backup_dir)
1037                                 goto options_rejected;
1038                         clean_fname(backup_dir, 1);
1039                         if (check_filter(elp, backup_dir, 1) < 0) {
1040                             options_rejected:
1041                                 snprintf(err_buf, sizeof err_buf,
1042                                     "Your options have been rejected by the server.\n");
1043                                 return 0;
1044                         }
1045                 }
1046         }
1047
1048         if (!backup_suffix)
1049                 backup_suffix = backup_dir ? "" : BACKUP_SUFFIX;
1050         backup_suffix_len = strlen(backup_suffix);
1051         if (strchr(backup_suffix, '/') != NULL) {
1052                 snprintf(err_buf, sizeof err_buf,
1053                         "--suffix cannot contain slashes: %s\n",
1054                         backup_suffix);
1055                 return 0;
1056         }
1057         if (backup_dir) {
1058                 backup_dir_len = strlcpy(backup_dir_buf, backup_dir, sizeof backup_dir_buf);
1059                 backup_dir_remainder = sizeof backup_dir_buf - backup_dir_len;
1060                 if (backup_dir_remainder < 32) {
1061                         snprintf(err_buf, sizeof err_buf,
1062                                 "the --backup-dir path is WAY too long.\n");
1063                         return 0;
1064                 }
1065                 if (backup_dir_buf[backup_dir_len - 1] != '/') {
1066                         backup_dir_buf[backup_dir_len++] = '/';
1067                         backup_dir_buf[backup_dir_len] = '\0';
1068                 }
1069                 if (verbose > 1 && !am_sender) {
1070                         rprintf(FINFO, "backup_dir is %s\n",
1071                                 safe_fname(backup_dir_buf));
1072                 }
1073         } else if (!backup_suffix_len && (!am_server || !am_sender)) {
1074                 snprintf(err_buf, sizeof err_buf,
1075                         "--suffix cannot be a null string without --backup-dir\n");
1076                 return 0;
1077         }
1078         if (make_backups && !backup_dir)
1079                 omit_dir_times = 1;
1080
1081         if (log_format) {
1082                 if (log_format_has(log_format, 'i'))
1083                         log_format_has_i = 1;
1084                 if (!log_format_has(log_format, 'b')
1085                  && !log_format_has(log_format, 'c'))
1086                         log_before_transfer = !am_server;
1087         } else if (itemize_changes) {
1088                 log_format = "%i %n%L";
1089                 log_format_has_i = 1;
1090                 log_before_transfer = !am_server;
1091         }
1092
1093         if ((do_progress || dry_run) && !verbose && !log_before_transfer
1094             && !am_server)
1095                 verbose = 1;
1096
1097         if (verbose && !log_format) {
1098                 log_format = "%n%L";
1099                 log_before_transfer = !am_server;
1100         }
1101         if (log_format_has_i || log_format_has(log_format, 'o'))
1102                 log_format_has_o_or_i = 1;
1103
1104         if (daemon_bwlimit && (!bwlimit || bwlimit > daemon_bwlimit))
1105                 bwlimit = daemon_bwlimit;
1106         if (bwlimit) {
1107                 bwlimit_writemax = (size_t)bwlimit * 128;
1108                 if (bwlimit_writemax < 512)
1109                         bwlimit_writemax = 512;
1110         }
1111
1112         if (delay_updates && !partial_dir)
1113                 partial_dir = partialdir_for_delayupdate;
1114
1115         if (inplace) {
1116 #ifdef HAVE_FTRUNCATE
1117                 if (partial_dir) {
1118                         snprintf(err_buf, sizeof err_buf,
1119                                  "--inplace cannot be used with --%s\n",
1120                                  delay_updates ? "delay-updates" : "partial-dir");
1121                         return 0;
1122                 }
1123                 /* --inplace implies --partial for refusal purposes, but we
1124                  * clear the keep_partial flag for internal logic purposes. */
1125                 if (refused_partial) {
1126                         create_refuse_error(refused_partial);
1127                         return 0;
1128                 }
1129                 keep_partial = 0;
1130 #else
1131                 snprintf(err_buf, sizeof err_buf,
1132                          "--inplace is not supported on this %s\n",
1133                          am_server ? "server" : "client");
1134                 return 0;
1135 #endif
1136         } else {
1137                 if (keep_partial && !partial_dir) {
1138                         if ((arg = getenv("RSYNC_PARTIAL_DIR")) != NULL && *arg)
1139                                 partial_dir = strdup(arg);
1140                 }
1141                 if (partial_dir) {
1142                         if (*partial_dir)
1143                                 clean_fname(partial_dir, 1);
1144                         if (!*partial_dir || strcmp(partial_dir, ".") == 0)
1145                                 partial_dir = NULL;
1146                         else if (*partial_dir != '/') {
1147                                 parse_rule(&filter_list, partial_dir,
1148                                     MATCHFLG_NO_PREFIXES|MATCHFLG_DIRECTORY, 0);
1149                         }
1150                         if (!partial_dir && refused_partial) {
1151                                 create_refuse_error(refused_partial);
1152                                 return 0;
1153                         }
1154                         keep_partial = 1;
1155                 }
1156         }
1157
1158         if (files_from) {
1159                 char *h, *p;
1160                 int q;
1161                 if (*argc > 2 || (!am_daemon && *argc == 1)) {
1162                         usage(FERROR);
1163                         exit_cleanup(RERR_SYNTAX);
1164                 }
1165                 if (strcmp(files_from, "-") == 0) {
1166                         filesfrom_fd = 0;
1167                         if (am_server)
1168                                 filesfrom_host = ""; /* reading from socket */
1169                 } else if ((p = check_for_hostspec(files_from, &h, &q)) != 0) {
1170                         if (am_server) {
1171                                 snprintf(err_buf, sizeof err_buf,
1172                                         "The --files-from sent to the server cannot specify a host.\n");
1173                                 return 0;
1174                         }
1175                         files_from = p;
1176                         filesfrom_host = h;
1177                         if (strcmp(files_from, "-") == 0) {
1178                                 snprintf(err_buf, sizeof err_buf,
1179                                         "Invalid --files-from remote filename\n");
1180                                 return 0;
1181                         }
1182                 } else {
1183                         if (sanitize_paths)
1184                                 files_from = sanitize_path(NULL, files_from, NULL, 0);
1185                         if (server_filter_list.head) {
1186                                 if (!*files_from)
1187                                         goto options_rejected;
1188                                 clean_fname(files_from, 1);
1189                                 if (check_filter(&server_filter_list, files_from, 0) < 0)
1190                                         goto options_rejected;
1191                         }
1192                         filesfrom_fd = open(files_from, O_RDONLY|O_BINARY);
1193                         if (filesfrom_fd < 0) {
1194                                 snprintf(err_buf, sizeof err_buf,
1195                                         "failed to open files-from file %s: %s\n",
1196                                         files_from, strerror(errno));
1197                                 return 0;
1198                         }
1199                 }
1200         }
1201
1202         am_starting_up = 0;
1203
1204         return 1;
1205 }
1206
1207
1208 /**
1209  * Construct a filtered list of options to pass through from the
1210  * client to the server.
1211  *
1212  * This involves setting options that will tell the server how to
1213  * behave, and also filtering out options that are processed only
1214  * locally.
1215  **/
1216 void server_options(char **args,int *argc)
1217 {
1218         static char argstr[50+MAX_BASIS_DIRS*2];
1219         int ac = *argc;
1220         char *arg;
1221
1222         int i, x;
1223
1224         if (blocking_io == -1)
1225                 blocking_io = 0;
1226
1227         args[ac++] = "--server";
1228
1229         if (daemon_over_rsh) {
1230                 args[ac++] = "--daemon";
1231                 *argc = ac;
1232                 /* if we're passing --daemon, we're done */
1233                 return;
1234         }
1235
1236         if (!am_sender)
1237                 args[ac++] = "--sender";
1238
1239         x = 1;
1240         argstr[0] = '-';
1241         for (i = 0; i < verbose; i++)
1242                 argstr[x++] = 'v';
1243
1244         /* the -q option is intentionally left out */
1245         if (make_backups)
1246                 argstr[x++] = 'b';
1247         if (update_only)
1248                 argstr[x++] = 'u';
1249         if (dry_run)
1250                 argstr[x++] = 'n';
1251         if (preserve_links)
1252                 argstr[x++] = 'l';
1253         if (copy_links)
1254                 argstr[x++] = 'L';
1255         if (xfer_dirs > 1)
1256                 argstr[x++] = 'd';
1257         if (keep_dirlinks && am_sender)
1258                 argstr[x++] = 'K';
1259
1260         if (whole_file > 0)
1261                 argstr[x++] = 'W';
1262         /* We don't need to send --no-whole-file, because it's the
1263          * default for remote transfers, and in any case old versions
1264          * of rsync will not understand it. */
1265
1266         if (preserve_hard_links)
1267                 argstr[x++] = 'H';
1268         if (preserve_uid)
1269                 argstr[x++] = 'o';
1270         if (preserve_gid)
1271                 argstr[x++] = 'g';
1272         if (preserve_devices)
1273                 argstr[x++] = 'D';
1274         if (preserve_times)
1275                 argstr[x++] = 't';
1276         if (omit_dir_times == 2 && am_sender)
1277                 argstr[x++] = 'O';
1278         if (preserve_perms)
1279                 argstr[x++] = 'p';
1280         if (recurse)
1281                 argstr[x++] = 'r';
1282         if (always_checksum)
1283                 argstr[x++] = 'c';
1284         if (cvs_exclude)
1285                 argstr[x++] = 'C';
1286         if (ignore_times)
1287                 argstr[x++] = 'I';
1288         if (relative_paths)
1289                 argstr[x++] = 'R';
1290         if (one_file_system)
1291                 argstr[x++] = 'x';
1292         if (sparse_files)
1293                 argstr[x++] = 'S';
1294         if (do_compression)
1295                 argstr[x++] = 'z';
1296
1297         /* This is a complete hack - blame Rusty.  FIXME!
1298          * This hack is only needed for older rsync versions that
1299          * don't understand the --list-only option. */
1300         if (list_only == 1 && !recurse)
1301                 argstr[x++] = 'r';
1302
1303         argstr[x] = 0;
1304
1305         if (x != 1)
1306                 args[ac++] = argstr;
1307
1308         if (list_only > 1)
1309                 args[ac++] = "--list-only";
1310
1311         /* The server side doesn't use our log-format, but in certain
1312          * circumstances they need to know a little about the option. */
1313         if (log_format && am_sender) {
1314                 if (log_format_has_i)
1315                         args[ac++] = "--log-format=%i";
1316                 else if (log_format_has_o_or_i)
1317                         args[ac++] = "--log-format=%o";
1318                 else if (!verbose)
1319                         args[ac++] = "--log-format=X";
1320         }
1321
1322         if (block_size) {
1323                 if (asprintf(&arg, "-B%lu", block_size) < 0)
1324                         goto oom;
1325                 args[ac++] = arg;
1326         }
1327
1328         if (max_delete && am_sender) {
1329                 if (asprintf(&arg, "--max-delete=%d", max_delete) < 0)
1330                         goto oom;
1331                 args[ac++] = arg;
1332         }
1333
1334         if (max_size && am_sender) {
1335                 args[ac++] = "--max-size";
1336                 args[ac++] = max_size_arg;
1337         }
1338
1339         if (io_timeout) {
1340                 if (asprintf(&arg, "--timeout=%d", io_timeout) < 0)
1341                         goto oom;
1342                 args[ac++] = arg;
1343         }
1344
1345         if (bwlimit) {
1346                 if (asprintf(&arg, "--bwlimit=%d", bwlimit) < 0)
1347                         goto oom;
1348                 args[ac++] = arg;
1349         }
1350
1351         if (backup_dir) {
1352                 args[ac++] = "--backup-dir";
1353                 args[ac++] = backup_dir;
1354         }
1355
1356         /* Only send --suffix if it specifies a non-default value. */
1357         if (strcmp(backup_suffix, backup_dir ? "" : BACKUP_SUFFIX) != 0) {
1358                 /* We use the following syntax to avoid weirdness with '~'. */
1359                 if (asprintf(&arg, "--suffix=%s", backup_suffix) < 0)
1360                         goto oom;
1361                 args[ac++] = arg;
1362         }
1363
1364         if (am_sender) {
1365                 if (delete_excluded)
1366                         args[ac++] = "--delete-excluded";
1367                 else if (delete_before == 1 || delete_after)
1368                         args[ac++] = "--delete";
1369                 if (delete_before > 1)
1370                         args[ac++] = "--delete-before";
1371                 if (delete_during)
1372                         args[ac++] = "--delete-during";
1373                 if (delete_after)
1374                         args[ac++] = "--delete-after";
1375                 if (force_delete)
1376                         args[ac++] = "--force";
1377         }
1378
1379         if (size_only)
1380                 args[ac++] = "--size-only";
1381
1382         if (modify_window_set) {
1383                 if (asprintf(&arg, "--modify-window=%d", modify_window) < 0)
1384                         goto oom;
1385                 args[ac++] = arg;
1386         }
1387
1388         if (checksum_seed) {
1389                 if (asprintf(&arg, "--checksum-seed=%d", checksum_seed) < 0)
1390                         goto oom;
1391                 args[ac++] = arg;
1392         }
1393
1394         if (partial_dir && am_sender) {
1395                 if (partial_dir != partialdir_for_delayupdate) {
1396                         args[ac++] = "--partial-dir";
1397                         args[ac++] = partial_dir;
1398                 }
1399                 if (delay_updates)
1400                         args[ac++] = "--delay-updates";
1401         } else if (keep_partial)
1402                 args[ac++] = "--partial";
1403
1404         if (ignore_errors)
1405                 args[ac++] = "--ignore-errors";
1406
1407         if (copy_unsafe_links)
1408                 args[ac++] = "--copy-unsafe-links";
1409
1410         if (safe_symlinks)
1411                 args[ac++] = "--safe-links";
1412
1413         if (numeric_ids)
1414                 args[ac++] = "--numeric-ids";
1415
1416         if (only_existing && am_sender)
1417                 args[ac++] = "--existing";
1418
1419         if (opt_ignore_existing && am_sender)
1420                 args[ac++] = "--ignore-existing";
1421
1422         if (inplace)
1423                 args[ac++] = "--inplace";
1424
1425         if (tmpdir) {
1426                 args[ac++] = "--temp-dir";
1427                 args[ac++] = tmpdir;
1428         }
1429
1430         if (basis_dir[0] && am_sender) {
1431                 /* the server only needs this option if it is not the sender,
1432                  *   and it may be an older version that doesn't know this
1433                  *   option, so don't send it if client is the sender.
1434                  */
1435                 int i;
1436                 for (i = 0; i < basis_dir_cnt; i++) {
1437                         args[ac++] = dest_option;
1438                         args[ac++] = basis_dir[i];
1439                 }
1440         }
1441
1442         if (files_from && (!am_sender || filesfrom_host)) {
1443                 if (filesfrom_host) {
1444                         args[ac++] = "--files-from";
1445                         args[ac++] = files_from;
1446                         if (eol_nulls)
1447                                 args[ac++] = "--from0";
1448                 } else {
1449                         args[ac++] = "--files-from=-";
1450                         args[ac++] = "--from0";
1451                 }
1452                 if (!relative_paths)
1453                         args[ac++] = "--no-relative";
1454         }
1455         if (!implied_dirs && !am_sender)
1456                 args[ac++] = "--no-implied-dirs";
1457
1458         if (fuzzy_basis && am_sender)
1459                 args[ac++] = "--fuzzy";
1460
1461         if (remove_sent_files)
1462                 args[ac++] = "--remove-sent-files";
1463
1464         *argc = ac;
1465         return;
1466
1467     oom:
1468         out_of_memory("server_options");
1469 }
1470
1471 /* Look for a HOST specfication of the form "HOST:PATH", "HOST::PATH", or
1472  * "rsync://HOST:PORT/PATH".  If found, *host_ptr will be set to some allocated
1473  * memory with the HOST.  If a daemon-accessing spec was specified, the value
1474  * of *port_ptr will contain a non-0 port number, otherwise it will be set to
1475  * 0.  The return value is a pointer to the PATH.  Note that the HOST spec can
1476  * be an IPv6 literal address enclosed in '[' and ']' (such as "[::1]" or
1477  * "[::ffff:127.0.0.1]") which is returned without the '[' and ']'. */
1478 char *check_for_hostspec(char *s, char **host_ptr, int *port_ptr)
1479 {
1480         char *p;
1481         int not_host;
1482
1483         if (port_ptr && strncasecmp(URL_PREFIX, s, strlen(URL_PREFIX)) == 0) {
1484                 char *path;
1485                 int hostlen;
1486                 s += strlen(URL_PREFIX);
1487                 if ((p = strchr(s, '/')) != NULL) {
1488                         hostlen = p - s;
1489                         path = p + 1;
1490                 } else {
1491                         hostlen = strlen(s);
1492                         path = "";
1493                 }
1494                 if (*s == '[' && (p = strchr(s, ']')) != NULL) {
1495                         s++;
1496                         hostlen = p - s;
1497                         if (p[1] == ':')
1498                                 *port_ptr = atoi(p+2);
1499                 } else {
1500                         if ((p = strchr(s, ':')) != NULL) {
1501                                 hostlen = p - s;
1502                                 *port_ptr = atoi(p+1);
1503                         }
1504                 }
1505                 if (!*port_ptr)
1506                         *port_ptr = RSYNC_PORT;
1507                 *host_ptr = new_array(char, hostlen + 1);
1508                 strlcpy(*host_ptr, s, hostlen + 1);
1509                 return path;
1510         }
1511
1512         if (*s == '[' && (p = strchr(s, ']')) != NULL && p[1] == ':') {
1513                 s++;
1514                 *p = '\0';
1515                 not_host = strchr(s, '/') || !strchr(s, ':');
1516                 *p = ']';
1517                 if (not_host)
1518                         return NULL;
1519                 p++;
1520         } else {
1521                 if (!(p = strchr(s, ':')))
1522                         return NULL;
1523                 *p = '\0';
1524                 not_host = strchr(s, '/') != NULL;
1525                 *p = ':';
1526                 if (not_host)
1527                         return NULL;
1528         }
1529
1530         *host_ptr = new_array(char, p - s + 1);
1531         strlcpy(*host_ptr, s, p - s + 1);
1532
1533         if (p[1] == ':') {
1534                 if (port_ptr && !*port_ptr)
1535                         *port_ptr = RSYNC_PORT;
1536                 return p + 2;
1537         }
1538         if (port_ptr)
1539                 *port_ptr = 0;
1540
1541         return p + 1;
1542 }