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