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