options.c

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