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