manpagez: man pages & more
man rsync(1)
Home | About | info | man | News  
rsync(1)                                                              rsync(1)




NAME

       rsync -- a fast, versatile, remote (and local) file-copying tool


SYNOPSIS

       Local:  rsync [OPTION...] SRC... [DEST]

       Access via remote shell:
         Pull: rsync [OPTION...] [USER@]HOST:SRC... [DEST]
         Push: rsync [OPTION...] SRC... [USER@]HOST:DEST

       Access via rsync daemon:
         Pull: rsync [OPTION...] [USER@]HOST::SRC... [DEST]
               rsync [OPTION...] rsync://[USER@]HOST[:PORT]/SRC... [DEST]
         Push: rsync [OPTION...] SRC... [USER@]HOST::DEST
               rsync [OPTION...] SRC... rsync://[USER@]HOST[:PORT]/DEST


       Usages with just one SRC arg and no DEST arg will list the source files
       instead of copying.



DESCRIPTION

       Rsync is a fast and extraordinarily versatile file  copying  tool.   It
       can  copy  locally,  to/from  another  host  over  any remote shell, or
       to/from a remote rsync daemon.  It offers a  large  number  of  options
       that  control  every  aspect  of  its behavior and permit very flexible
       specification of the set of files to be copied.  It is famous  for  its
       delta-transfer  algorithm,  which  reduces the amount of data sent over
       the network by sending only the differences between  the  source  files
       and  the  existing  files in the destination.  Rsync is widely used for
       backups and mirroring and as an improved copy command for everyday use.

       Rsync  finds  files  that  need to be transferred using a "quick check"
       algorithm (by default) that looks for files that have changed  in  size
       or   in  last-modified  time.   Any  changes  in  the  other  preserved
       attributes (as requested by options) are made on the  destination  file
       directly  when  the quick check indicates that the file's data does not
       need to be updated.

       Some of the additional features of rsync are:


       o      support for copying links, devices, owners, groups, and  permis-
              sions

       o      exclude and exclude-from options similar to GNU tar

       o      a  CVS  exclude  mode for ignoring the same files that CVS would
              ignore

       o      can use any transparent remote shell, including ssh or rsh

       o      does not require super-user privileges

       o      pipelining of file transfers to minimize latency costs

       o      support for anonymous or authenticated rsync daemons (ideal  for
              mirroring)




GENERAL

       Rsync  copies  files either to or from a remote host, or locally on the
       current host (it does not support  copying  files  between  two  remote
       hosts).

       There  are  two  different  ways  for rsync to contact a remote system:
       using a remote-shell program as the transport (such as ssh or  rsh)  or
       contacting  an  rsync daemon directly via TCP.  The remote-shell trans-
       port is used whenever the source or destination path contains a  single
       colon  (:)  separator  after a host specification.  Contacting an rsync
       daemon directly happens when the source or destination path contains  a
       double  colon  (::)  separator  after  a host specification, OR when an
       rsync:// URL is specified (see also the  "USING  RSYNC-DAEMON  FEATURES
       VIA  A REMOTE-SHELL CONNECTION" section for an exception to this latter
       rule).

       As a special case, if a single source arg is specified without a desti-
       nation, the files are listed in an output format similar to "ls -l".

       As expected, if neither the source or destination path specify a remote
       host, the copy occurs locally (see also the --list-only option).



SETUP

       See the file README for installation instructions.

       Once installed, you can use rsync to any machine that  you  can  access
       via a remote shell (as well as some that you can access using the rsync
       daemon-mode protocol).  For remote transfers, a modern rsync  uses  ssh
       for  its  communications, but it may have been configured to use a dif-
       ferent remote shell by default, such as rsh or remsh.

       You can also specify any remote shell you like, either by using the  -e
       command  line option, or by setting the RSYNC_RSH environment variable.

       Note that rsync must be installed on both the  source  and  destination
       machines.



USAGE

       You  use  rsync  in the same way you use rcp. You must specify a source
       and a destination, one of which may be remote.

       Perhaps the best way to explain the syntax is with some examples:

              rsync -t *.c foo:src/


       This would transfer all files matching the pattern *.c from the current
       directory  to the directory src on the machine foo. If any of the files
       already exist on the remote system then the rsync remote-update  proto-
       col is used to update the file by sending only the differences. See the
       tech report for details.

              rsync -avz foo:src/bar /data/tmp


       This would recursively transfer all files from the directory src/bar on
       the  machine foo into the /data/tmp/bar directory on the local machine.
       The files are transferred in "archive" mode, which  ensures  that  sym-
       bolic  links,  devices,  attributes,  permissions, ownerships, etc. are
       preserved in the transfer.  Additionally, compression will be  used  to
       reduce the size of data portions of the transfer.

              rsync -avz foo:src/bar/ /data/tmp


       A  trailing slash on the source changes this behavior to avoid creating
       an additional directory level at the destination.  You can think  of  a
       trailing / on a source as meaning "copy the contents of this directory"
       as opposed to "copy the directory by  name",  but  in  both  cases  the
       attributes  of the containing directory are transferred to the contain-
       ing directory on the destination.  In other words, each of the  follow-
       ing  commands copies the files in the same way, including their setting
       of the attributes of /dest/foo:

              rsync -av /src/foo /dest
              rsync -av /src/foo/ /dest/foo


       Note also that host and module  references  don't  require  a  trailing
       slash to copy the contents of the default directory.  For example, both
       of these copy the remote directory's contents into "/dest":

              rsync -av host: /dest
              rsync -av host::module /dest


       You can also use rsync in local-only mode, where both  the  source  and
       destination  don't have a `:' in the name. In this case it behaves like
       an improved copy command.

       Finally, you can list all the (listable) modules available from a  par-
       ticular rsync daemon by leaving off the module name:

              rsync somehost.mydomain.com::


       See the following section for more details.



ADVANCED USAGE

       The  syntax for requesting multiple files from a remote host is done by
       specifying additional remote-host args in the same style as the  first,
       or with the hostname omitted.  For instance, all these work:

              rsync -av host:file1 :file2 host:file{3,4} /dest/
              rsync -av host::modname/file{1,2} host::modname/file3 /dest/
              rsync -av host::modname/file1 ::modname/file{3,4}


       Older  versions  of rsync required using quoted spaces in the SRC, like
       these examples:

              rsync -av host:'dir1/file1 dir2/file2' /dest
              rsync host::'modname/dir1/file1 modname/dir2/file2' /dest


       This word-splitting still works (by default) in the latest  rsync,  but
       is not as easy to use as the first method.

       If  you  need  to transfer a filename that contains whitespace, you can
       either specify the --protect-args (-s) option, or you'll need to escape
       the  whitespace  in  a  way that the remote shell will understand.  For
       instance:

              rsync -av host:'file\ name\ with\ spaces' /dest




CONNECTING TO AN RSYNC DAEMON

       It is also possible to use rsync without a remote shell as  the  trans-
       port.  In this case you will directly connect to a remote rsync daemon,
       typically using TCP port 873.  (This obviously requires the  daemon  to
       be running on the remote system, so refer to the STARTING AN RSYNC DAE-
       MON TO ACCEPT CONNECTIONS section below for information on that.)

       Using rsync in this way is the same as using it  with  a  remote  shell
       except that:


       o      you  either  use  a double colon :: instead of a single colon to
              separate the hostname from the path, or you use an rsync:// URL.

       o      the first word of the "path" is actually a module name.

       o      the  remote  daemon may print a message of the day when you con-
              nect.

       o      if you specify no path name on the remote daemon then  the  list
              of accessible paths on the daemon will be shown.

       o      if you specify no local destination then a listing of the speci-
              fied files on the remote daemon is provided.

       o      you must not specify the --rsh (-e) option.


       An example that copies all the files in a remote module named "src":

           rsync -av host::src /dest


       Some modules on the remote daemon may require  authentication.  If  so,
       you  will receive a password prompt when you connect. You can avoid the
       password prompt by setting the environment variable  RSYNC_PASSWORD  to
       the  password you want to use or using the --password-file option. This
       may be useful when scripting rsync.

       WARNING: On some systems  environment  variables  are  visible  to  all
       users. On those systems using --password-file is recommended.

       You  may  establish the connection via a web proxy by setting the envi-
       ronment variable RSYNC_PROXY to a hostname:port pair pointing  to  your
       web proxy.  Note that your web proxy's configuration must support proxy
       connections to port 873.

       You may also establish a daemon connection using a program as  a  proxy
       by  setting the environment variable RSYNC_CONNECT_PROG to the commands
       you wish to run in place of making a  direct  socket  connection.   The
       string  may contain the escape "%H" to represent the hostname specified
       in the rsync command (so use "%%" if you need  a  single  "%"  in  your
       string).  For example:

         export RSYNC_CONNECT_PROG='ssh proxyhost nc %H 873'
         rsync -av targethost1::module/src/ /dest/
         rsync -av rsync:://targethost2/module/src/ /dest/


       The command specified above uses ssh to run nc (netcat) on a proxyhost,
       which forwards all data to port 873 (the rsync daemon) on the  targeth-
       ost (%H).



USING RSYNC-DAEMON FEATURES VIA A REMOTE-SHELL CONNECTION

       It is sometimes useful to use various features of an rsync daemon (such
       as named modules) without actually allowing any new socket  connections
       into  a  system  (other  than what is already required to allow remote-
       shell access).  Rsync supports connecting to  a  host  using  a  remote
       shell  and  then  spawning a single-use "daemon" server that expects to
       read its config file in the home dir of the remote user.  This  can  be
       useful if you want to encrypt a daemon-style transfer's data, but since
       the daemon is started up fresh by the remote user, you may not be  able
       to  use  features  such as chroot or change the uid used by the daemon.
       (For another way to encrypt a daemon transfer, consider  using  ssh  to
       tunnel  a  local  port to a remote machine and configure a normal rsync
       daemon on that remote host to only allow connections from "localhost".)

       From  the user's perspective, a daemon transfer via a remote-shell con-
       nection uses nearly the same command-line syntax as a normal rsync-dae-
       mon  transfer,  with  the only exception being that you must explicitly
       set the remote shell program on the command-line with the --rsh=COMMAND
       option.   (Setting  the  RSYNC_RSH  in the environment will not turn on
       this functionality.)  For example:

           rsync -av --rsh=ssh host::module /dest


       If you need to specify a different remote-shell user, keep in mind that
       the  user@  prefix  in  front  of the host is specifying the rsync-user
       value (for a module that  requires  user-based  authentication).   This
       means  that  you  must give the '-l user' option to ssh when specifying
       the remote-shell, as in this example that uses the short version of the
       --rsh option:

           rsync -av -e "ssh -l ssh-user" rsync-user@host::module /dest


       The  "ssh-user" will be used at the ssh level; the "rsync-user" will be
       used to log-in to the "module".



STARTING AN RSYNC DAEMON TO ACCEPT CONNECTIONS

       In order to connect to an rsync daemon, the remote system needs to have
       a daemon already running (or it needs to have configured something like
       inetd to spawn an rsync daemon for incoming connections on a particular
       port).   For  full  information on how to start a daemon that will han-
       dling incoming socket connections, see the rsyncd.conf(5) man  page  --
       that  is  the  config  file  for  the  daemon, and it contains the full
       details for how to run the daemon (including stand-alone and inetd con-
       figurations).

       If  you're  using  one of the remote-shell transports for the transfer,
       there is no need to manually start an rsync daemon.



EXAMPLES

       Here are some examples of how I use rsync.

       To backup my wife's home directory, which consists  of  large  MS  Word
       files and mail folders, I use a cron job that runs

              rsync -Cavz . arvidsjaur:backup


       each night over a PPP connection to a duplicate directory on my machine
       "arvidsjaur".

       To synchronize my samba source trees I use the following Makefile  tar-
       gets:

           get:
                   rsync -avuzb --exclude '*~' samba:samba/ .
           put:
                   rsync -Cavuzb . samba:samba/
           sync: get put


       this  allows  me  to  sync with a CVS directory at the other end of the
       connection. I then do CVS operations on the remote machine, which saves
       a lot of time as the remote CVS protocol isn't very efficient.

       I mirror a directory between my "old" and "new" ftp sites with the com-
       mand:

       rsync -az -e ssh --delete ~ftp/pub/samba nimbus:"~ftp/pub/tridge"

       This is launched from cron every few hours.



OPTIONS SUMMARY

       Here is a short summary of the options available in rsync. Please refer
       to the detailed description below for a complete description.

        -v, --verbose               increase verbosity
        -q, --quiet                 suppress non-error messages
            --no-motd               suppress daemon-mode MOTD (see caveat)
        -c, --checksum              skip based on checksum, not mod-time & size
        -a, --archive               archive mode; equals -rlptgoD (no -H,-A,-X)
            --no-OPTION             turn off an implied OPTION (e.g. --no-D)
        -r, --recursive             recurse into directories
        -R, --relative              use relative path names
            --no-implied-dirs       don't send implied dirs with --relative
        -b, --backup                make backups (see --suffix & --backup-dir)
            --backup-dir=DIR        make backups into hierarchy based in DIR
            --suffix=SUFFIX         backup suffix (default ~ w/o --backup-dir)
        -u, --update                skip files that are newer on the receiver
            --inplace               update destination files in-place
            --append                append data onto shorter files
            --append-verify         --append w/old data in file checksum
        -d, --dirs                  transfer directories without recursing
        -l, --links                 copy symlinks as symlinks
        -L, --copy-links            transform symlink into referent file/dir
            --copy-unsafe-links     only "unsafe" symlinks are transformed
            --safe-links            ignore symlinks that point outside the tree
        -k, --copy-dirlinks         transform symlink to dir into referent dir
        -K, --keep-dirlinks         treat symlinked dir on receiver as dir
        -H, --hard-links            preserve hard links
        -p, --perms                 preserve permissions
        -E, --executability         preserve executability
            --chmod=CHMOD           affect file and/or directory permissions
        -A, --acls                  preserve ACLs (implies -p)
        -X, --xattrs                preserve extended attributes
        -o, --owner                 preserve owner (super-user only)
        -g, --group                 preserve group
            --devices               preserve device files (super-user only)
            --specials              preserve special files
        -D                          same as --devices --specials
        -t, --times                 preserve modification times
        -O, --omit-dir-times        omit directories from --times
            --super                 receiver attempts super-user activities
            --fake-super            store/recover privileged attrs using xattrs
        -S, --sparse                handle sparse files efficiently
        -n, --dry-run               perform a trial run with no changes made
        -W, --whole-file            copy files whole (w/o delta-xfer algorithm)
        -x, --one-file-system       don't cross filesystem boundaries
        -B, --block-size=SIZE       force a fixed checksum block-size
        -e, --rsh=COMMAND           specify the remote shell to use
            --rsync-path=PROGRAM    specify the rsync to run on remote machine
            --existing              skip creating new files on receiver
            --ignore-existing       skip updating files that exist on receiver
            --remove-source-files   sender removes synchronized files (non-dir)
            --del                   an alias for --delete-during
            --delete                delete extraneous files from dest dirs
            --delete-before         receiver deletes before transfer (default)
            --delete-during         receiver deletes during xfer, not before
            --delete-delay          find deletions during, delete after
            --delete-after          receiver deletes after transfer, not before
            --delete-excluded       also delete excluded files from dest dirs
            --ignore-errors         delete even if there are I/O errors
            --force                 force deletion of dirs even if not empty
            --max-delete=NUM        don't delete more than NUM files
            --max-size=SIZE         don't transfer any file larger than SIZE
            --min-size=SIZE         don't transfer any file smaller than SIZE
            --partial               keep partially transferred files
            --partial-dir=DIR       put a partially transferred file into DIR
            --delay-updates         put all updated files into place at end
        -m, --prune-empty-dirs      prune empty directory chains from file-list
            --numeric-ids           don't map uid/gid values by user/group name
            --timeout=SECONDS       set I/O timeout in seconds
            --contimeout=SECONDS    set daemon connection timeout in seconds
        -I, --ignore-times          don't skip files that match size and time
            --size-only             skip files that match in size
            --modify-window=NUM     compare mod-times with reduced accuracy
        -T, --temp-dir=DIR          create temporary files in directory DIR
        -y, --fuzzy                 find similar file for basis if no dest file
            --compare-dest=DIR      also compare received files relative to DIR
            --copy-dest=DIR         ... and include copies of unchanged files
            --link-dest=DIR         hardlink to files in DIR when unchanged
        -z, --compress              compress file data during the transfer
            --compress-level=NUM    explicitly set compression level
            --skip-compress=LIST    skip compressing files with suffix in LIST
        -C, --cvs-exclude           auto-ignore files in the same way CVS does
        -f, --filter=RULE           add a file-filtering RULE
        -F                          same as --filter='dir-merge /.rsync-filter'
                                    repeated: --filter='- .rsync-filter'
            --exclude=PATTERN       exclude files matching PATTERN
            --exclude-from=FILE     read exclude patterns from FILE
            --include=PATTERN       don't exclude files matching PATTERN
            --include-from=FILE     read include patterns from FILE
            --files-from=FILE       read list of source-file names from FILE
        -0, --from0                 all *from/filter files are delimited by 0s
        -s, --protect-args          no space-splitting; wildcard chars only
            --address=ADDRESS       bind address for outgoing socket to daemon
            --port=PORT             specify double-colon alternate port number
            --sockopts=OPTIONS      specify custom TCP options
            --blocking-io           use blocking I/O for the remote shell
            --stats                 give some file-transfer stats
        -8, --8-bit-output          leave high-bit chars unescaped in output
        -h, --human-readable        output numbers in a human-readable format
            --progress              show progress during transfer
        -P                          same as --partial --progress
        -i, --itemize-changes       output a change-summary for all updates
            --out-format=FORMAT     output updates using the specified FORMAT
            --log-file=FILE         log what we're doing to the specified FILE
            --log-file-format=FMT   log updates using the specified FMT
            --password-file=FILE    read daemon-access password from FILE
            --list-only             list the files instead of copying them
            --bwlimit=KBPS          limit I/O bandwidth; KBytes per second
            --write-batch=FILE      write a batched update to FILE
            --only-write-batch=FILE like --write-batch but w/o updating dest
            --read-batch=FILE       read a batched update from FILE
            --protocol=NUM          force an older protocol version to be used
            --iconv=CONVERT_SPEC    request charset conversion of filenames
            --checksum-seed=NUM     set block/file checksum seed (advanced)
        -4, --ipv4                  prefer IPv4
        -6, --ipv6                  prefer IPv6
            --version               print version number
       (-h) --help                  show this help (see below for -h comment)


       Rsync  can also be run as a daemon, in which case the following options
       are accepted:

            --daemon                run as an rsync daemon
            --address=ADDRESS       bind to the specified address
            --bwlimit=KBPS          limit I/O bandwidth; KBytes per second
            --config=FILE           specify alternate rsyncd.conf file
            --no-detach             do not detach from the parent
            --port=PORT             listen on alternate port number
            --log-file=FILE         override the "log file" setting
            --log-file-format=FMT   override the "log format" setting
            --sockopts=OPTIONS      specify custom TCP options
        -v, --verbose               increase verbosity
        -4, --ipv4                  prefer IPv4
        -6, --ipv6                  prefer IPv6
        -h, --help                  show this help (if used after --daemon)




OPTIONS

       rsync uses the GNU long options  package.  Many  of  the  command  line
       options  have  two  variants,  one short and one long.  These are shown
       below, separated by commas. Some options only have a long variant.  The
       `='  for  options  that take a parameter is optional; whitespace can be
       used instead.


       --help Print a short help page  describing  the  options  available  in
              rsync  and exit.  For backward-compatibility with older versions
              of rsync, the help will also be output if you use the -h  option
              without any other args.


       --version
              print the rsync version number and exit.


       -v, --verbose
              This  option  increases  the amount of information you are given
              during the transfer.  By default, rsync works silently. A single
              -v  will  give you information about what files are being trans-
              ferred and a brief summary at the end. Two -v  flags  will  give
              you  information  on  what  files are being skipped and slightly
              more information at the end. More than two -v flags should  only
              be used if you are debugging rsync.

              Note that the names of the transferred files that are output are
              done using a default --out-format of  "%n%L",  which  tells  you
              just  the  name of the file and, if the item is a link, where it
              points.  At the single -v level of verbosity, this does not men-
              tion when a file gets its attributes changed.  If you ask for an
              itemized list of changed attributes (either --itemize-changes or
              adding  "%i"  to  the  --out-format setting), the output (on the
              client) increases to mention all items that are changed  in  any
              way.  See the --out-format option for more details.


       -q, --quiet
              This  option  decreases  the amount of information you are given
              during the transfer, notably  suppressing  information  messages
              from  the remote server. This flag is useful when invoking rsync
              from cron.


       --no-motd
              This option affects the information that is output by the client
              at the start of a daemon transfer.  This suppresses the message-
              of-the-day (MOTD) text, but it also affects the list of  modules
              that  the daemon sends in response to the "rsync host::" request
              (due to a limitation in the rsync protocol), so omit this option
              if you want to request the list of modules from the daemon.


       -I, --ignore-times
              Normally  rsync  will  skip  any files that are already the same
              size and have the  same  modification  timestamp.   This  option
              turns  off  this "quick check" behavior, causing all files to be
              updated.


       --size-only
              This modifies rsync's "quick check" algorithm for finding  files
              that  need  to  be  transferred, changing it from the default of
              transferring files with either a changed size or a changed last-
              modified  time  to  just  looking for files that have changed in
              size.  This is useful when starting to  use  rsync  after  using
              another  mirroring  system  which  may  not  preserve timestamps
              exactly.


       --modify-window
              When comparing two timestamps, rsync treats  the  timestamps  as
              being  equal  if  they  differ by no more than the modify-window
              value.  This is normally 0 (for an exact  match),  but  you  may
              find it useful to set this to a larger value in some situations.
              In particular, when transferring to or from an  MS  Windows  FAT
              filesystem  (which represents times with a 2-second resolution),
              --modify-window=1 is useful (allowing times to differ by up to 1
              second).


       -c, --checksum
              This changes the way rsync checks if the files have been changed
              and are in need of a transfer.  Without this option, rsync  uses
              a "quick check" that (by default) checks if each file's size and
              time of last modification match between the sender and receiver.
              This  option  changes this to compare a 128-bit MD4 checksum for
              each file that has a matching size.   Generating  the  checksums
              means  that both sides will expend a lot of disk I/O reading all
              the data in the files in the transfer (and this is prior to  any
              reading  that  will  be done to transfer changed files), so this
              can slow things down significantly.

              The sending side generates its checksums while it is  doing  the
              file-system  scan  that  builds the list of the available files.
              The receiver generates its checksums when  it  is  scanning  for
              changed files, and will checksum any file that has the same size
              as the corresponding sender's file:  files with either a changed
              size or a changed checksum are selected for transfer.

              Note  that  rsync always verifies that each transferred file was
              correctly reconstructed on the  receiving  side  by  checking  a
              whole-file  checksum  that  is  generated  as the file is trans-
              ferred, but that automatic after-the-transfer  verification  has
              nothing  to do with this option's before-the-transfer "Does this
              file need to be updated?" check.


       -a, --archive
              This is equivalent to -rlptgoD. It is a quick way of saying  you
              want  recursion  and want to preserve almost everything (with -H
              being a notable omission).  The  only  exception  to  the  above
              equivalence  is when --files-from is specified, in which case -r
              is not implied.

              Note that -a does not preserve hardlinks, because finding multi-
              ply-linked  files is expensive.  You must separately specify -H.


       --no-OPTION
              You may turn off one or more implied options  by  prefixing  the
              option  name with "no-".  Not all options may be prefixed with a
              "no-": only options that are  implied  by  other  options  (e.g.
              --no-D,  --no-perms)  or have different defaults in various cir-
              cumstances (e.g. --no-whole-file, --no-blocking-io,  --no-dirs).
              You  may  specify either the short or the long option name after
              the "no-" prefix (e.g. --no-R is the same as --no-relative).

              For example: if you want to use -a (--archive) but don't want -o
              (--owner),  instead  of  converting  -a  into -rlptgD, you could
              specify -a --no-o (or -a --no-owner).

              The order of the options is important:  if  you  specify  --no-r
              -a,  the -r option would end up being turned on, the opposite of
              -a --no-r.  Note also that the side-effects of the  --files-from
              option  are  NOT  positional, as it affects the default state of
              several options and slightly changes the meaning of -a (see  the
              --files-from option for more details).


       -r, --recursive
              This  tells  rsync  to  copy  directories recursively.  See also
              --dirs (-d).

              Beginning with rsync 3.0.0, the recursive algorithm used is  now
              an  incremental  scan that uses much less memory than before and
              begins the transfer after the scanning of the first few directo-
              ries  have  been  completed.  This incremental scan only affects
              our recursion algorithm, and does  not  change  a  non-recursive
              transfer.  It is also only possible when both ends of the trans-
              fer are at least version 3.0.0.

              Some options require rsync to know the full file list, so  these
              options  disable the incremental recursion mode.  These include:
              --delete-before,   --delete-after,    --prune-empty-dirs,    and
              --delay-updates.   Because of this, the default delete mode when
              you specify --delete is now --delete-during when  both  ends  of
              the  connection are at least 3.0.0 (use --del or --delete-during
              to request this improved deletion mode  explicitly).   See  also
              the  --delete-delay  option  that  is a better choice than using
              --delete-after.

              Incremental recursion can be disabled using the  --no-inc-recur-
              sive option or its shorter --no-i-r alias.


       -R, --relative
              Use  relative  paths. This means that the full path names speci-
              fied on the command line are sent to the server rather than just
              the  last  parts  of  the filenames. This is particularly useful
              when you want to send several different directories at the  same
              time. For example, if you used this command:

                 rsync -av /foo/bar/baz.c remote:/tmp/


              ...  this would create a file named baz.c in /tmp/ on the remote
              machine. If instead you used

                 rsync -avR /foo/bar/baz.c remote:/tmp/


              then a file named /tmp/foo/bar/baz.c would  be  created  on  the
              remote machine, preserving its full path.  These extra path ele-
              ments are called "implied directories" (i.e. the "foo"  and  the
              "foo/bar" directories in the above example).

              Beginning  with  rsync  3.0.0,  rsync always sends these implied
              directories as real directories in the file list, even if a path
              element  is really a symlink on the sending side.  This prevents
              some really unexpected behaviors when copying the full path of a
              file  that you didn't realize had a symlink in its path.  If you
              want to duplicate a server-side symlink, include both  the  sym-
              link via its path, and referent directory via its real path.  If
              you're dealing with an older rsync on the sending side, you  may
              need to use the --no-implied-dirs option.

              It is also possible to limit the amount of path information that
              is sent as implied directories for each path you specify.   With
              a  modern  rsync on the sending side (beginning with 2.6.7), you
              can insert a dot and a slash into the source path, like this:

                 rsync -avR /foo/./bar/baz.c remote:/tmp/


              That would create /tmp/bar/baz.c on the remote  machine.   (Note
              that  the dot must be followed by a slash, so "/foo/." would not
              be abbreviated.)  (2) For older rsync versions, you  would  need
              to  use  a  chdir  to  limit the source path.  For example, when
              pushing files:

                 (cd /foo; rsync -avR bar/baz.c remote:/tmp/)


              (Note that the parens put the two commands into a sub-shell,  so
              that  the  "cd" command doesn't remain in effect for future com-
              mands.)  If you're pulling files from an older rsync,  use  this
              idiom (but only for a non-daemon transfer):

                 rsync -avR --rsync-path="cd /foo; rsync" \
                     remote:bar/baz.c /tmp/



       --no-implied-dirs
              This  option  affects  the  default  behavior  of the --relative
              option.  When it is specified, the  attributes  of  the  implied
              directories from the source names are not included in the trans-
              fer.  This means that the corresponding  path  elements  on  the
              destination  system  are  left  unchanged if they exist, and any
              missing implied directories are created with default attributes.
              This even allows these implied path elements to have big differ-
              ences, such as being a symlink to a directory on  the  receiving
              side.

              For  instance,  if a command-line arg or a files-from entry told
              rsync to transfer  the  file  "path/foo/file",  the  directories
              "path"  and  "path/foo" are implied when --relative is used.  If
              "path/foo" is a symlink to "bar" on the destination system,  the
              receiving  rsync would ordinarily delete "path/foo", recreate it
              as a directory, and receive the file  into  the  new  directory.
              With    --no-implied-dirs,    the    receiving   rsync   updates
              "path/foo/file" using the existing path  elements,  which  means
              that  the file ends up being created in "path/bar".  Another way
              to  accomplish  this   link   preservation   is   to   use   the
              --keep-dirlinks  option  (which  will  also  affect  symlinks to
              directories in the rest of the transfer).

              When pulling files from an rsync older than 3.0.0, you may  need
              to use this option if the sending side has a symlink in the path
              you request and you wish the implied directories  to  be  trans-
              ferred as normal directories.


       -b, --backup
              With  this  option, preexisting destination files are renamed as
              each file is transferred or deleted.  You can control where  the
              backup  file  goes  and what (if any) suffix gets appended using
              the --backup-dir and --suffix options.

              Note  that  if  you  don't   specify   --backup-dir,   (1)   the
              --omit-dir-times  option will be implied, and (2) if --delete is
              also in effect (without --delete-excluded),  rsync  will  add  a
              "protect"  filter-rule  for  the backup suffix to the end of all
              your existing excludes (e.g. -f "Pp  *~").   This  will  prevent
              previously backed-up files from being deleted.  Note that if you
              are supplying your own filter rules, you may  need  to  manually
              insert  your own exclude/protect rule somewhere higher up in the
              list so that it has a  high  enough  priority  to  be  effective
              (e.g.,  if  your rules specify a trailing inclusion/exclusion of
              `*', the auto-added rule would never be reached).


       --backup-dir=DIR
              In combination with the --backup option,  this  tells  rsync  to
              store  all  backups  in the specified directory on the receiving
              side.  This can be used for incremental backups.  You can  addi-
              tionally specify a backup suffix using the --suffix option (oth-
              erwise the files backed up in the specified directory will  keep
              their original filenames).


       --suffix=SUFFIX
              This  option  allows  you  to override the default backup suffix
              used with the --backup (-b) option. The default suffix is a ~ if
              no  --backup-dir was specified, otherwise it is an empty string.


       -u, --update
              This forces rsync to skip any files which exist on the  destina-
              tion  and  have  a  modified  time that is newer than the source
              file.  (If an existing destination file has a modification  time
              equal  to the source file's, it will be updated if the sizes are
              different.)

              Note that this does not affect the copying of symlinks or  other
              special  files.   Also,  a difference of file format between the
              sender and receiver is always considered to be important  enough
              for  an update, no matter what date is on the objects.  In other
              words, if the source has a directory where the destination has a
              file, the transfer would occur regardless of the timestamps.


       --inplace
              This  option  changes how rsync transfers a file when the file's
              data needs to be updated: instead of the default method of  cre-
              ating a new copy of the file and moving it into place when it is
              complete, rsync instead writes the updated data directly to  the
              destination file.

              This  has several effects: (1) in-use binaries cannot be updated
              (either the OS will prevent this  from  happening,  or  binaries
              that attempt to swap-in their data will misbehave or crash), (2)
              the file's data will be in  an  inconsistent  state  during  the
              transfer, (3) a file's data may be left in an inconsistent state
              after the transfer if the  transfer  is  interrupted  or  if  an
              update  fails,  (4)  a file that does not have write permissions
              can not be updated, and (5) the  efficiency  of  rsync's  delta-
              transfer  algorithm  may be reduced if some data in the destina-
              tion file is overwritten before it can be copied to  a  position
              later  in the file (one exception to this is if you combine this
              option with --backup, since rsync is smart  enough  to  use  the
              backup file as the basis file for the transfer).

              WARNING: you should not use this option to update files that are
              being accessed by others, so be careful  when  choosing  to  use
              this for a copy.

              This  option  is  useful for transfer of large files with block-
              based changes or appended data, and also  on  systems  that  are
              disk bound, not network bound.

              The option implies --partial (since an interrupted transfer does
              not delete the  file),  but  conflicts  with  --partial-dir  and
              --delay-updates.  Prior to rsync 2.6.4 --inplace was also incom-
              patible with --compare-dest and --link-dest.


       --append
              This causes rsync to update a file by appending  data  onto  the
              end  of  the  file,  which  presumes  that the data that already
              exists on the receiving side is identical with the start of  the
              file on the sending side.  If a file needs to be transferred and
              its size on the receiver is the same or longer than the size  on
              the  sender,  the file is skipped.  This does not interfere with
              the updating of a file's non-content  attributes  (e.g.  permis-
              sions, ownership, etc.) when the file does not need to be trans-
              ferred, nor does it  affect  the  updating  of  any  non-regular
              files.   Implies  --inplace, but does not conflict with --sparse
              (since it is always extending a file's length).


       --append-verify
              This works just like the --append option, but the existing  data
              on the receiving side is included in the full-file checksum ver-
              ification step, which will cause a file  to  be  resent  if  the
              final  verification step fails (rsync uses a normal, non-append-
              ing --inplace transfer for the resend).

              Note: prior to rsync 3.0.0,  the  --append  option  worked  like
              --append-verify,  so  if you are interacting with an older rsync
              (or the transfer is using a protocol prior  to  30),  specifying
              either  append option will initiate an --append-verify transfer.


       -d, --dirs
              Tell the sending  side  to  include  any  directories  that  are
              encountered.  Unlike --recursive, a directory's contents are not
              copied unless the directory name specified is "." or ends with a
              trailing  slash (e.g. ".", "dir/.", "dir/", etc.).  Without this
              option or the --recursive option, rsync will skip  all  directo-
              ries it encounters (and output a message to that effect for each
              one).  If you specify both --dirs and  --recursive,  --recursive
              takes precedence.

              The  --dirs  option is implied by the --files-from option or the
              --list-only option (including an implied --list-only  usage)  if
              --recursive  wasn't  specified  (so that directories are seen in
              the listing).  Specify --no-dirs (or --no-d) if you want to turn
              this off.

              There is also a backward-compatibility helper option, --old-dirs
              (or  --old-d)  that  tells  rsync  to  use   a   hack   of   "-r
              --exclude='/*/*'"  to get an older rsync to list a single direc-
              tory without recursing.


       -l, --links
              When symlinks are encountered, recreate the symlink on the  des-
              tination.


       -L, --copy-links
              When  symlinks are encountered, the item that they point to (the
              referent) is copied, rather than the symlink.  In older versions
              of  rsync,  this  option also had the side-effect of telling the
              receiving side to follow symlinks, such as symlinks to  directo-
              ries.   In a modern rsync such as this one, you'll need to spec-
              ify --keep-dirlinks (-K) to get this extra behavior.   The  only
              exception  is  when sending files to an rsync that is too old to
              understand -K -- in that case, the -L option will still have the
              side-effect of -K on that older receiving rsync.


       --copy-unsafe-links
              This  tells  rsync  to  copy the referent of symbolic links that
              point outside the  copied  tree.   Absolute  symlinks  are  also
              treated  like  ordinary  files,  and  so are any symlinks in the
              source path itself when --relative is used.  This option has  no
              additional effect if --copy-links was also specified.


       --safe-links
              This  tells  rsync to ignore any symbolic links which point out-
              side the copied tree. All absolute symlinks  are  also  ignored.
              Using  this option in conjunction with --relative may give unex-
              pected results.


       -k, --copy-dirlinks
              This option causes the sending side to  treat  a  symlink  to  a
              directory as though it were a real directory.  This is useful if
              you don't want symlinks to non-directories to  be  affected,  as
              they would be using --copy-links.

              Without  this  option, if the sending side has replaced a direc-
              tory with a symlink to a  directory,  the  receiving  side  will
              delete anything that is in the way of the new symlink, including
              a directory hierarchy (as long as  --force  or  --delete  is  in
              effect).

              See also --keep-dirlinks for an analogous option for the receiv-
              ing side.


       -K, --keep-dirlinks
              This option causes the receiving side to treat a  symlink  to  a
              directory  as  though  it  were a real directory, but only if it
              matches a real directory from the sender.  Without this  option,
              the receiver's symlink would be deleted and replaced with a real
              directory.

              For example, suppose you transfer a directory  "foo"  that  con-
              tains  a  file "file", but "foo" is a symlink to directory "bar"
              on the receiver.  Without --keep-dirlinks, the receiver  deletes
              symlink  "foo",  recreates  it  as a directory, and receives the
              file into the new directory.  With --keep-dirlinks, the receiver
              keeps the symlink and "file" ends up in "bar".

              One note of caution:  if you use --keep-dirlinks, you must trust
              all the symlinks  in  the  copy!   If  it  is  possible  for  an
              untrusted user to create their own symlink to any directory, the
              user could then (on a subsequent copy) replace the symlink  with
              a  real  directory  and affect the content of whatever directory
              the symlink references.  For backup copies, you are  better  off
              using something like a bind mount instead of a symlink to modify
              your receiving hierarchy.

              See also --copy-dirlinks for an analogous option for the sending
              side.


       -H, --hard-links
              This  tells  rsync to look for hard-linked files in the transfer
              and link together the corresponding files on the receiving side.
              Without  this  option,  hard-linked  files  in  the transfer are
              treated as though they were separate files.

              When you are updating a non-empty destination, this option  only
              ensures  that  files that are hard-linked together on the source
              are hard-linked together on the destination.  It does  NOT  cur-
              rently endeavor to break already existing hard links on the des-
              tination that do not exist between the source files.  Note, how-
              ever,  that  if  one  or  more  extra-linked  files have content
              changes, they will become unlinked when  updated  (assuming  you
              are not using the --inplace option).

              Note  that  rsync  can only detect hard links between files that
              are inside the transfer set.  If rsync updates a file  that  has
              extra  hard-link connections to files outside the transfer, that
              linkage will be broken.  If you are tempted to use the --inplace
              option to avoid this breakage, be very careful that you know how
              your files are being updated so that you  are  certain  that  no
              unintended  changes  happen due to lingering hard links (and see
              the --inplace option for more caveats).

              If incremental recursion is active (see --recursive), rsync  may
              transfer a missing hard-linked file before it finds that another
              link for that contents exists elsewhere in the hierarchy.   This
              does  not  affect  the  accuracy of the transfer, just its effi-
              ciency.  One way to avoid this is to disable incremental  recur-
              sion using the --no-inc-recursive option.


       -p, --perms
              This  option  causes  the receiving rsync to set the destination
              permissions to be the same as the source permissions.  (See also
              the  --chmod  option for a way to modify what rsync considers to
              be the source permissions.)

              When this option is off, permissions are set as follows:


              o      Existing files (including  updated  files)  retain  their
                     existing  permissions,  though the --executability option
                     might change just the execute permission for the file.

              o      New files get their "normal" permission bits set  to  the
                     source  file's  permissions  masked  with  the  receiving
                     directory's default  permissions  (either  the  receiving
                     process's  umask,  or  the  permissions specified via the
                     destination directory's default ACL), and  their  special
                     permission  bits  disabled except in the case where a new
                     directory inherits a setgid bit from  its  parent  direc-
                     tory.


              Thus,  when  --perms  and  --executability  are  both  disabled,
              rsync's behavior is the same as that of other  file-copy  utili-
              ties, such as cp(1) and tar(1).

              In  summary:  to  give  destination files (both old and new) the
              source permissions, use --perms.  To give new files the destina-
              tion-default   permissions   (while   leaving   existing   files
              unchanged), make sure that the --perms option  is  off  and  use
              --chmod=ugo=rwX  (which  ensures  that  all  non-masked bits get
              enabled).  If you'd care to make this latter behavior easier  to
              type, you could define a popt alias for it, such as putting this
              line in the file ~/.popt (the following defines the  -Z  option,
              and  includes --no-g to use the default group of the destination
              dir):

                 rsync alias -Z --no-p --no-g --chmod=ugo=rwX


              You could then use this new option in a  command  such  as  this
              one:

                 rsync -avZ src/ dest/


              (Caveat:  make  sure  that -a does not follow -Z, or it will re-
              enable the two "--no-*" options mentioned above.)

              The preservation of the destination's setgid bit  on  newly-cre-
              ated  directories  when --perms is off was added in rsync 2.6.7.
              Older rsync versions erroneously  preserved  the  three  special
              permission  bits  for  newly-created files when --perms was off,
              while overriding the  destination's  setgid  bit  setting  on  a
              newly-created  directory.   Default  ACL observance was added to
              the ACL patch for rsync 2.6.7,  so  older  (or  non-ACL-enabled)
              rsyncs use the umask even if default ACLs are present.  (Keep in
              mind that it is the version of the receiving rsync that  affects
              these behaviors.)


       -E, --executability
              This  option causes rsync to preserve the executability (or non-
              executability) of regular files when --perms is not enabled.   A
              regular  file is considered to be executable if at least one `x'
              is turned on in its permissions.  When an  existing  destination
              file's  executability  differs  from  that  of the corresponding
              source file, rsync modifies the destination  file's  permissions
              as follows:


              o      To  make  a  file non-executable, rsync turns off all its
                     `x' permissions.

              o      To make a file executable, rsync turns on each  `x'  per-
                     mission  that has a corresponding `r' permission enabled.


              If --perms is enabled, this option is ignored.


       -A, --acls
              This option causes rsync to update the destination  ACLs  to  be
              the same as the source ACLs.  The option also implies --perms.

              The  source  and  destination  systems  must have compatible ACL
              entries for this option to work properly.  See the  --fake-super
              option for a way to backup and restore ACLs that are not compat-
              ible.


       -X, --xattrs
              This  option  causes  rsync  to  update  the   remote   extended
              attributes to be the same as the local ones.

              For  systems  that support extended-attribute namespaces, a copy
              being done by a super-user copies  all  namespaces  except  sys-
              tem.*.   A  normal user only copies the user.* namespace.  To be
              able to backup and restore non-user namespaces as a normal user,
              see the --fake-super option.


       --chmod
              This  option  tells  rsync  to apply one or more comma-separated
              "chmod" strings to the permission of the files in the  transfer.
              The  resulting value is treated as though it was the permissions
              that the sending side supplied for the file,  which  means  that
              this  option  can  seem  to  have no effect on existing files if
              --perms is not enabled.

              In addition  to  the  normal  parsing  rules  specified  in  the
              chmod(1) manpage, you can specify an item that should only apply
              to a directory by prefixing it with a `D', or  specify  an  item
              that  should  only  apply  to a file by prefixing it with a `F'.
              For example:

              --chmod=Dg+s,ug+w,Fo-w,+X


              It is also legal to specify multiple --chmod  options,  as  each
              additional  option  is  just  appended to the list of changes to
              make.

              See the --perms and --executability options for how the  result-
              ing  permission  value can be applied to the files in the trans-
              fer.


       -o, --owner
              This option causes rsync to set the  owner  of  the  destination
              file  to be the same as the source file, but only if the receiv-
              ing rsync is being run as the super-user (see also  the  --super
              and  --fake-super  options).   Without this option, the owner of
              new and/or transferred files are set to the invoking user on the
              receiving side.

              The  preservation  of ownership will associate matching names by
              default, but may fall back to using the ID number in  some  cir-
              cumstances (see also the --numeric-ids option for a full discus-
              sion).


       -g, --group
              This option causes rsync to set the  group  of  the  destination
              file  to  be the same as the source file.  If the receiving pro-
              gram is not running as the  super-user  (or  if  --no-super  was
              specified),  only groups that the invoking user on the receiving
              side is a member of will be preserved.  Without this option, the
              group  is  set  to the default group of the invoking user on the
              receiving side.

              The preservation of group information  will  associate  matching
              names  by  default,  but may fall back to using the ID number in
              some circumstances (see also the --numeric-ids option for a full
              discussion).


       --devices
              This  option causes rsync to transfer character and block device
              files to the remote system  to  recreate  these  devices.   This
              option  has  no  effect if the receiving rsync is not run as the
              super-user (see also the --super and --fake-super options).


       --specials
              This option causes rsync to transfer special files such as named
              sockets and fifos.


       -D     The -D option is equivalent to --devices --specials.


       -t, --times
              This  tells  rsync to transfer modification times along with the
              files and update them on the remote system.  Note that  if  this
              option  is  not  used, the optimization that excludes files that
              have not been modified cannot be effective; in  other  words,  a
              missing -t or -a will cause the next transfer to behave as if it
              used -I, causing all files to be updated (though rsync's  delta-
              transfer  algorithm will make the update fairly efficient if the
              files haven't actually changed, you're  much  better  off  using
              -t).


       -O, --omit-dir-times
              This tells rsync to omit directories when it is preserving modi-
              fication times (see --times).  If NFS is sharing the directories
              on the receiving side, it is a good idea to use -O.  This option
              is inferred if you use --backup without --backup-dir.


       --super
              This tells the receiving side to attempt  super-user  activities
              even if the receiving rsync wasn't run by the super-user.  These
              activities include: preserving users  via  the  --owner  option,
              preserving  all  groups (not just the current user's groups) via
              the --groups option,  and  copying  devices  via  the  --devices
              option.   This  is useful for systems that allow such activities
              without being the super-user, and also  for  ensuring  that  you
              will get errors if the receiving side isn't being running as the
              super-user.  To turn off super-user activities,  the  super-user
              can use --no-super.


       --fake-super
              When  this option is enabled, rsync simulates super-user activi-
              ties by saving/restoring the privileged attributes  via  special
              extended  attributes that are attached to each file (as needed).
              This includes the file's owner and  group  (if  it  is  not  the
              default),  the  file's  device  info (device & special files are
              created as empty text files), and any permission  bits  that  we
              won't allow to be set on the real file (e.g.  the real file gets
              u-s,g-s,o-t for safety) or that would limit the  owner's  access
              (since  the real super-user can always access/change a file, the
              files we create can always be accessed/changed by  the  creating
              user).   This option also handles ACLs (if --acls was specified)
              and non-user extended attributes (if --xattrs was specified).

              This is a good way to backup data without  using  a  super-user,
              and to store ACLs from incompatible systems.

              The  --fake-super  option only affects the side where the option
              is used.  To affect the remote side of  a  remote-shell  connec-
              tion, specify an rsync path:

                rsync -av --rsync-path="rsync --fake-super" /src/ host:/dest/


              Since  there  is  only  one  "side" in a local copy, this option
              affects both the sending and receiving of files.  You'll need to
              specify a copy using "localhost" if you need to avoid this, pos-
              sibly using the "lsh" shell script (from the support  directory)
              as a substitute for an actual remote shell (see --rsh).

              This option is overridden by both --super and --no-super.

              See  also  the  "fake super" setting in the daemon's rsyncd.conf
              file.


       -S, --sparse
              Try to handle sparse files efficiently  so  they  take  up  less
              space on the destination.  Conflicts with --inplace because it's
              not possible to overwrite data in a sparse fashion.

              NOTE: Don't use this option when the destination  is  a  Solaris
              "tmpfs"  filesystem.  It  doesn't seem to handle seeks over null
              regions correctly and ends up corrupting the files.


       -n, --dry-run
              This makes rsync perform a  trial  run  that  doesn't  make  any
              changes (and produces mostly the same output as a real run).  It
              is most commonly used in  combination  with  the  -v,  --verbose
              and/or  -i,  --itemize-changes options to see what an rsync com-
              mand is going to do before one actually runs it.

              The output of --itemize-changes is supposed to  be  exactly  the
              same on a dry run and a subsequent real run (barring intentional
              trickery and system call failures); if it isn't, that's  a  bug.
              Other output is the same to the extent practical, but may differ
              in some areas.  Notably, a dry run does not send the actual data
              for  file  transfers,  so  --progress  has no effect, the "bytes
              sent", "bytes received", "literal data", and "matched data" sta-
              tistics  are too small, and the "speedup" value is equivalent to
              a run where no file transfers are needed.


       -W, --whole-file
              With this option rsync's delta-transfer algorithm  is  not  used
              and  the  whole file is sent as-is instead.  The transfer may be
              faster if this option is used when  the  bandwidth  between  the
              source  and destination machines is higher than the bandwidth to
              disk  (especially  when  the  "disk"  is  actually  a  networked
              filesystem).   This is the default when both the source and des-
              tination are specified as local paths.


       -x, --one-file-system
              This tells rsync to avoid crossing a  filesystem  boundary  when
              recursing.   This  does  not limit the user's ability to specify
              items to copy from multiple filesystems, just rsync's  recursion
              through the hierarchy of each directory that the user specified,
              and also the analogous recursion on the  receiving  side  during
              deletion.  Also keep in mind that rsync treats a "bind" mount to
              the same device as being on the same filesystem.

              If this option is repeated, rsync omits all mount-point directo-
              ries  from  the copy.  Otherwise, it includes an empty directory
              at each mount-point it encounters (using the attributes  of  the
              mounted  directory  because  those of the underlying mount-point
              directory are inaccessible).

              If rsync has been told to collapse symlinks (via --copy-links or
              --copy-unsafe-links), a symlink to a directory on another device
              is treated like a mount-point.  Symlinks to non-directories  are
              unaffected by this option.


       --existing, --ignore-non-existing
              This  tells rsync to skip creating files (including directories)
              that do not exist yet on the destination.   If  this  option  is
              combined  with  the  --ignore-existing  option, no files will be
              updated (which can be useful if all you want  to  do  is  delete
              extraneous files).


       --ignore-existing
              This  tells  rsync  to skip updating files that already exist on
              the destination (this does not ignore existing  directories,  or
              nothing would get done).  See also --existing.

              This  option  can  be  useful  for those doing backups using the
              --link-dest option when they need to continue a backup run  that
              got  interrupted.   Since a --link-dest run is copied into a new
              directory hierarchy (when it is used properly),  using  --ignore
              existing  will  ensure  that the already-handled files don't get
              tweaked (which avoids a change in permissions on the hard-linked
              files).   This does mean that this option is only looking at the
              existing files in the destination hierarchy itself.


       --remove-source-files
              This tells rsync to remove  from  the  sending  side  the  files
              (meaning  non-directories)  that  are a part of the transfer and
              have been successfully duplicated on the receiving side.


       --delete
              This tells rsync to delete extraneous files from  the  receiving
              side  (ones  that  aren't on the sending side), but only for the
              directories that are being synchronized.  You  must  have  asked
              rsync to send the whole directory (e.g. "dir" or "dir/") without
              using a wildcard for the  directory's  contents  (e.g.  "dir/*")
              since  the wildcard is expanded by the shell and rsync thus gets
              a request to transfer individual files, not  the  files'  parent
              directory.   Files  that  are  excluded  from  transfer are also
              excluded from being deleted unless you use the --delete-excluded
              option  or  mark  the rules as only matching on the sending side
              (see the include/exclude modifiers in the FILTER RULES section).

              Prior  to  rsync  2.6.7, this option would have no effect unless
              --recursive was enabled.  Beginning with 2.6.7,  deletions  will
              also occur when --dirs (-d) is enabled, but only for directories
              whose contents are being copied.

              This option can be dangerous if used incorrectly!  It is a  very
              good  idea to first try a run using the --dry-run option (-n) to
              see what files are going to be deleted.

              If the sending side detects any I/O errors, then the deletion of
              any  files  at  the  destination will be automatically disabled.
              This is to prevent temporary filesystem failures  (such  as  NFS
              errors)  on the sending side causing a massive deletion of files
              on  the  destination.   You   can   override   this   with   the
              --ignore-errors option.

              The   --delete   option   may   be  combined  with  one  of  the
              --delete-WHEN   options   without   conflict,   as    well    as
              --delete-excluded.    However,  if  none  of  the  --delete-WHEN
              options are specified, rsync  will  choose  the  --delete-during
              algorithm  when  talking  to  an  rsync  3.0.0 or newer, and the
              --delete-before algorithm when talking to an older  rsync.   See
              also --delete-delay and --delete-after.


       --delete-before
              Request  that  the  file-deletions on the receiving side be done
              before the transfer starts.  See --delete (which is implied) for
              more details on file-deletion.

              Deleting  before  the  transfer  is helpful if the filesystem is
              tight for space and removing extraneous files would help to make
              the  transfer  possible.   However,  it  does  introduce a delay
              before the start of the transfer, and this delay might cause the
              transfer  to  timeout  (if  --timeout  was  specified).  It also
              forces rsync to use the old, non-incremental recursion algorithm
              that  requires  rsync to scan all the files in the transfer into
              memory at once (see --recursive).


       --delete-during, --del
              Request that the file-deletions on the receiving  side  be  done
              incrementally  as the transfer happens.  This is a faster method
              than choosing the before- or after-transfer algorithm, but it is
              only supported beginning with rsync version 2.6.4.  See --delete
              (which is implied) for more details on file-deletion.


       --delete-delay
              Request that the file-deletions on the receiving  side  be  com-
              puted  during  the transfer, and then removed after the transfer
              completes.  If the number of removed files overflows an internal
              buffer,  a  temporary file will be created on the receiving side
              to hold the names (it is removed while open,  so  you  shouldn't
              see  it  during the transfer).  If the creation of the temporary
              file fails, rsync will try to fall back to using  --delete-after
              (which  it  cannot  do  if  --recursive  is doing an incremental
              scan).


       --delete-after
              Request that the file-deletions on the receiving  side  be  done
              after  the  transfer  has  completed.  This is useful if you are
              sending new per-directory merge files as a part of the  transfer
              and  you  want  their  exclusions  to take effect for the delete
              phase of the current transfer.  It also forces rsync to use  the
              old,  non-incremental recursion algorithm that requires rsync to
              scan all the files in the transfer  into  memory  at  once  (see
              --recursive).   See --delete (which is implied) for more details
              on file-deletion.


       --delete-excluded
              In addition to deleting the files on the receiving side that are
              not  on  the  sending  side, this tells rsync to also delete any
              files on the receiving side that are excluded  (see  --exclude).
              See the FILTER RULES section for a way to make individual exclu-
              sions behave this way on the receiver, and for a way to  protect
              files  from  --delete-excluded.  See --delete (which is implied)
              for more details on file-deletion.


       --ignore-errors
              Tells --delete to go ahead and delete files even when there  are
              I/O errors.


       --force
              This  option tells rsync to delete a non-empty directory when it
              is to be replaced by a non-directory.  This is only relevant  if
              deletions are not active (see --delete for details).

              Note for older rsync versions: --force used to still be required
              when using --delete-after, and  it  used  to  be  non-functional
              unless the --recursive option was also enabled.


       --max-delete=NUM
              This  tells  rsync not to delete more than NUM files or directo-
              ries.  If that limit is exceeded, a warning is output and  rsync
              exits with an error code of 25 (new for 3.0.0).

              Also new for version 3.0.0, you may specify --max-delete=0 to be
              warned about any extraneous files  in  the  destination  without
              removing any of them.  Older clients interpreted this as "unlim-
              ited", so if you don't know what version the client is, you  can
              use  the  less  obvious --max-delete=-1 as a backward-compatible
              way to specify that no deletions be allowed (though  older  ver-
              sions didn't warn when the limit was exceeded).


       --max-size=SIZE
              This  tells  rsync to avoid transferring any file that is larger
              than the specified SIZE. The SIZE value can be suffixed  with  a
              string  to  indicate  a size multiplier, and may be a fractional
              value (e.g. "--max-size=1.5m").

              The suffixes are as  follows:  "K"  (or  "KiB")  is  a  kibibyte
              (1024),  "M"  (or  "MiB") is a mebibyte (1024*1024), and "G" (or
              "GiB") is a gibibyte (1024*1024*1024).  If you want  the  multi-
              plier  to  be  1000  instead  of  1024, use "KB", "MB", or "GB".
              (Note: lower-case is also accepted for all values.)  Finally, if
              the suffix ends in either "+1" or "-1", the value will be offset
              by one byte in the indicated direction.

              Examples:   --max-size=1.5mb-1    is    1499999    bytes,    and
              --max-size=2g+1 is 2147483649 bytes.


       --min-size=SIZE
              This  tells rsync to avoid transferring any file that is smaller
              than the specified SIZE, which  can  help  in  not  transferring
              small,  junk files.  See the --max-size option for a description
              of SIZE.


       -B, --block-size=BLOCKSIZE
              This forces the block size used in rsync's delta-transfer  algo-
              rithm  to  a  fixed value.  It is normally selected based on the
              size of each file being updated.  See the technical  report  for
              details.


       -e, --rsh=COMMAND
              This  option  allows  you  to choose an alternative remote shell
              program to use for communication between the  local  and  remote
              copies  of  rsync.  Typically, rsync is configured to use ssh by
              default, but you may prefer to use rsh on a local network.

              If this option is used with [user@]host::module/path,  then  the
              remote  shell COMMAND will be used to run an rsync daemon on the
              remote host, and all  data  will  be  transmitted  through  that
              remote  shell  connection,  rather  than through a direct socket
              connection to a running rsync daemon on the  remote  host.   See
              the section "USING RSYNC-DAEMON FEATURES VIA A REMOTE-SHELL CON-
              NECTION" above.

              Command-line arguments are permitted in  COMMAND  provided  that
              COMMAND  is  presented  to rsync as a single argument.  You must
              use spaces (not tabs or other whitespace) to separate  the  com-
              mand  and  args  from each other, and you can use single- and/or
              double-quotes to preserve spaces in an argument (but  not  back-
              slashes).   Note  that  doubling a single-quote inside a single-
              quoted string gives you a  single-quote;  likewise  for  double-
              quotes  (though  you  need to pay attention to which quotes your
              shell is parsing and which quotes rsync is parsing).  Some exam-
              ples:

                  -e 'ssh -p 2234'
                  -e 'ssh -o "ProxyCommand nohup ssh firewall nc -w1 %h %p"'


              (Note  that  ssh  users  can alternately customize site-specific
              connect options in their .ssh/config file.)

              You can also choose the remote shell program using the RSYNC_RSH
              environment  variable, which accepts the same range of values as
              -e.

              See also the --blocking-io option  which  is  affected  by  this
              option.


       --rsync-path=PROGRAM
              Use  this  to  specify  what  program is to be run on the remote
              machine to start-up rsync.  Often used when rsync is not in  the
              default            remote-shell's           path           (e.g.
              --rsync-path=/usr/local/bin/rsync).  Note that  PROGRAM  is  run
              with  the  help of a shell, so it can be any program, script, or
              command sequence you'd care to run, so long as it does not  cor-
              rupt  the standard-in & standard-out that rsync is using to com-
              municate.

              One tricky example is to set a different  default  directory  on
              the  remote  machine  for  use  with the --relative option.  For
              instance:

                  rsync -avR --rsync-path="cd /a/b && rsync" host:c/d /e/



       -C, --cvs-exclude
              This is a useful shorthand for excluding a broad range of  files
              that you often don't want to transfer between systems. It uses a
              similar algorithm to CVS  to  determine  if  a  file  should  be
              ignored.

              The  exclude  list is initialized to exclude the following items
              (these initial items are marked as perishable -- see the  FILTER
              RULES section):

                     RCS   SCCS   CVS   CVS.adm   RCSLOG  cvslog.*  tags  TAGS
                     .make.state .nse_depinfo *~ #* .#* ,* _$* *$ *.old  *.bak
                     *.BAK  *.orig *.rej .del-* *.a *.olb *.o *.obj *.so *.exe
                     *.Z *.elc *.ln core .svn/ .git/ .bzr/


              then, files listed in a $HOME/.cvsignore are added to  the  list
              and  any files listed in the CVSIGNORE environment variable (all
              cvsignore names are delimited by whitespace).

              Finally, any file is ignored if it is in the same directory as a
              .cvsignore  file and matches one of the patterns listed therein.
              Unlike rsync's filter/exclude files, these patterns are split on
              whitespace.  See the cvs(1) manual for more information.

              If  you're combining -C with your own --filter rules, you should
              note that these CVS excludes are appended at the end of your own
              rules,  regardless  of  where  the -C was placed on the command-
              line.  This makes them a lower priority than any rules you spec-
              ified  explicitly.   If  you  want  to  control  where these CVS
              excludes get inserted into your filter rules,  you  should  omit
              the  -C as a command-line option and use a combination of --fil-
              ter=:C and  --filter=-C  (either  on  your  command-line  or  by
              putting  the  ":C"  and  "-C" rules into a filter file with your
              other rules).  The first option turns on the per-directory scan-
              ning for the .cvsignore file.  The second option does a one-time
              import of the CVS excludes mentioned above.


       -f, --filter=RULE
              This option allows you to add rules to selectively exclude  cer-
              tain  files  from  the  list of files to be transferred. This is
              most useful in combination with a recursive transfer.

              You may use as many --filter options on the command line as  you
              like  to  build  up the list of files to exclude.  If the filter
              contains whitespace, be sure to quote it so that the shell gives
              the  rule  to  rsync  as a single argument.  The text below also
              mentions that you can use an underscore  to  replace  the  space
              that separates a rule from its arg.

              See  the  FILTER  RULES section for detailed information on this
              option.


       -F     The -F option is a shorthand for adding two  --filter  rules  to
              your command.  The first time it is used is a shorthand for this
              rule:

                 --filter='dir-merge /.rsync-filter'


              This tells rsync to look for per-directory  .rsync-filter  files
              that  have  been  sprinkled  through the hierarchy and use their
              rules to filter the files in the transfer.  If -F  is  repeated,
              it is a shorthand for this rule:

                 --filter='exclude .rsync-filter'


              This  filters  out  the  .rsync-filter files themselves from the
              transfer.

              See the FILTER RULES section for  detailed  information  on  how
              these options work.


       --exclude=PATTERN
              This  option  is  a  simplified form of the --filter option that
              defaults to an exclude rule and does not allow  the  full  rule-
              parsing syntax of normal filter rules.

              See  the  FILTER  RULES section for detailed information on this
              option.


       --exclude-from=FILE
              This option is related to the --exclude option, but it specifies
              a  FILE  that  contains  exclude patterns (one per line).  Blank
              lines in the file  and  lines  starting  with  `;'  or  `#'  are
              ignored.   If  FILE  is  -,  the list will be read from standard
              input.


       --include=PATTERN
              This option is a simplified form of  the  --filter  option  that
              defaults  to  an  include rule and does not allow the full rule-
              parsing syntax of normal filter rules.

              See the FILTER RULES section for detailed  information  on  this
              option.


       --include-from=FILE
              This option is related to the --include option, but it specifies
              a FILE that contains include patterns  (one  per  line).   Blank
              lines  in  the  file  and  lines  starting  with  `;' or `#' are
              ignored.  If FILE is -, the list  will  be  read  from  standard
              input.


       --files-from=FILE
              Using  this option allows you to specify the exact list of files
              to transfer (as read from the specified FILE or -  for  standard
              input).   It  also  tweaks the default behavior of rsync to make
              transferring just the specified files and directories easier:


              o      The --relative (-R) option is  implied,  which  preserves
                     the  path  information that is specified for each item in
                     the file (use --no-relative or --no-R if you want to turn
                     that off).

              o      The  --dirs  (-d)  option  is  implied, which will create
                     directories specified in  the  list  on  the  destination
                     rather  than  noisily  skipping  them  (use  --no-dirs or
                     --no-d if you want to turn that off).

              o      The --archive  (-a)  option's  behavior  does  not  imply
                     --recursive  (-r),  so specify it explicitly, if you want
                     it.

              o      These side-effects change the default state of rsync,  so
                     the  position  of the --files-from option on the command-
                     line has no bearing on how other options are parsed (e.g.
                     -a  works  the same before or after --files-from, as does
                     --no-R and all other options).


              The filenames that are read from the FILE are  all  relative  to
              the  source  dir  -- any leading slashes are removed and no ".."
              references are allowed to go higher than the  source  dir.   For
              example, take this command:

                 rsync -a --files-from=/tmp/foo /usr remote:/backup


              If  /tmp/foo  contains  the  string  "bin" (or even "/bin"), the
              /usr/bin directory will be created as /backup/bin on the  remote
              host.   If  it  contains  "bin/"  (note the trailing slash), the
              immediate contents of the directory would also be sent  (without
              needing  to be explicitly mentioned in the file -- this began in
              version 2.6.4).  In both cases, if the -r  option  was  enabled,
              that  dir's  entire hierarchy would also be transferred (keep in
              mind that -r needs to be specified explicitly with --files-from,
              since  it  is  not implied by -a).  Also note that the effect of
              the (enabled by default) --relative option is to duplicate  only
              the  path  info  that is read from the file -- it does not force
              the duplication of the source-spec path (/usr in this case).

              In addition, the --files-from file can be read from  the  remote
              host instead of the local host if you specify a "host:" in front
              of the file (the host must match one end of the transfer).  As a
              short-cut, you can specify just a prefix of ":" to mean "use the
              remote end of the transfer".  For example:

                 rsync -a --files-from=:/path/file-list src:/ /tmp/copy


              This would copy all the files specified in  the  /path/file-list
              file that was located on the remote "src" host.


       -0, --from0
              This  tells  rsync that the rules/filenames it reads from a file
              are terminated by a null ('\0') character,  not  a  NL,  CR,  or
              CR+LF.     This    affects    --exclude-from,    --include-from,
              --files-from, and any merged files specified in a --filter rule.
              It  does  not  affect --cvs-exclude (since all names read from a
              .cvsignore file are split on whitespace).

              If the --iconv and --protect-args options are specified and  the
              --files-from  filenames are being sent from one host to another,
              the filenames will be translated from the sending host's charset
              to the receiving host's charset.


       -s, --protect-args
              This  option  sends all filenames and some options to the remote
              rsync without allowing the remote shell to interpret them.  This
              means  that  spaces are not split in names, and any non-wildcard
              special characters are not translated  (such  as  ~,  $,  ;,  &,
              etc.).   Wildcards  are  expanded  on  the  remote host by rsync
              (instead of the shell doing it).

              If you use this option with  --iconv,  the  args  will  also  be
              translated  from  the  local  to  the remote character-set.  The
              translation happens before wild-cards are  expanded.   See  also
              the --files-from option.


       -T, --temp-dir=DIR
              This  option  instructs  rsync to use DIR as a scratch directory
              when creating temporary copies of the files transferred  on  the
              receiving  side.   The default behavior is to create each tempo-
              rary file in the same directory as  the  associated  destination
              file.

              This option is most often used when the receiving disk partition
              does not have enough free space to hold a copy  of  the  largest
              file  in  the  transfer.   In  this  case (i.e. when the scratch
              directory is on a different disk partition), rsync will  not  be
              able  to rename each received temporary file over the top of the
              associated destination file,  but  instead  must  copy  it  into
              place.   Rsync does this by copying the file over the top of the
              destination file, which means that  the  destination  file  will
              contain  truncated data during this copy.  If this were not done
              this way (even if the destination file were first  removed,  the
              data  locally  copied  to  a  temporary  file in the destination
              directory, and then renamed into place) it would be possible for
              the old file to continue taking up disk space (if someone had it
              open), and thus there might not be enough room to  fit  the  new
              version on the disk at the same time.

              If  you  are using this option for reasons other than a shortage
              of  disk  space,  you  may  wish  to   combine   it   with   the
              --delay-updates  option, which will ensure that all copied files
              get put into subdirectories in the destination hierarchy, await-
              ing  the  end of the transfer.  If you don't have enough room to
              duplicate all the arriving files on the  destination  partition,
              another way to tell rsync that you aren't overly concerned about
              disk space is to use the --partial-dir option  with  a  relative
              path; because this tells rsync that it is OK to stash off a copy
              of a single file in a subdir in the destination hierarchy, rsync
              will  use  the  partial-dir  as a staging area to bring over the
              copied file, and then rename it into place from there. (Specify-
              ing  a  --partial-dir  with  an absolute path does not have this
              side-effect.)


       -y, --fuzzy
              This option tells rsync that it should look for a basis file for
              any  destination  file  that  is missing.  The current algorithm
              looks in the same directory as the destination file for either a
              file  that  has  an identical size and modified-time, or a simi-
              larly-named file.  If found, rsync uses the fuzzy basis file  to
              try to speed up the transfer.

              Note  that  the  use of the --delete option might get rid of any
              potential fuzzy-match files, so  either  use  --delete-after  or
              specify some filename exclusions if you need to prevent this.


       --compare-dest=DIR
              This  option  instructs  rsync  to  use  DIR  on the destination
              machine as an additional hierarchy to compare destination  files
              against  doing transfers (if the files are missing in the desti-
              nation directory).  If a file is found in DIR that is  identical
              to  the  sender's  file, the file will NOT be transferred to the
              destination directory.  This is useful  for  creating  a  sparse
              backup of just files that have changed from an earlier backup.

              Beginning  in version 2.6.4, multiple --compare-dest directories
              may be provided, which will cause rsync to search  the  list  in
              the  order  specified  for  an exact match.  If a match is found
              that differs only in attributes, a local copy is  made  and  the
              attributes  updated.  If a match is not found, a basis file from
              one of the DIRs will be selected to try to speed up  the  trans-
              fer.

              If  DIR  is  a  relative path, it is relative to the destination
              directory.  See also --copy-dest and --link-dest.


       --copy-dest=DIR
              This option behaves like --compare-dest,  but  rsync  will  also
              copy  unchanged  files found in DIR to the destination directory
              using a local copy.  This is useful for doing transfers to a new
              destination  while leaving existing files intact, and then doing
              a flash-cutover when all files  have  been  successfully  trans-
              ferred.

              Multiple  --copy-dest  directories  may  be provided, which will
              cause rsync to search the list in the  order  specified  for  an
              unchanged  file.  If a match is not found, a basis file from one
              of the DIRs will be selected to try to speed up the transfer.

              If DIR is a relative path, it is  relative  to  the  destination
              directory.  See also --compare-dest and --link-dest.


       --link-dest=DIR
              This  option  behaves  like --copy-dest, but unchanged files are
              hard linked from DIR to the destination  directory.   The  files
              must be identical in all preserved attributes (e.g. permissions,
              possibly  ownership)  in  order  for  the  files  to  be  linked
              together.  An example:

                rsync -av --link-dest=$PWD/prior_dir host:src_dir/ new_dir/


              Beginning in version 2.6.4, multiple --link-dest directories may
              be provided, which will cause rsync to search the  list  in  the
              order  specified  for  an exact match.  If a match is found that
              differs only in  attributes,  a  local  copy  is  made  and  the
              attributes  updated.  If a match is not found, a basis file from
              one of the DIRs will be selected to try to speed up  the  trans-
              fer.

              This  option  works  best when copying into an empty destination
              hierarchy, as rsync treats existing files as definitive  (so  it
              never  looks  in  the  link-dest  dirs  when  a destination file
              already exists), and  as  malleable  (so  it  might  change  the
              attributes  of  a  destination file, which affects all the hard-
              linked versions).

              Note that if you combine this option with --ignore-times,  rsync
              will not link any files together because it only links identical
              files together as a substitute for transferring the file,  never
              as an additional check after the file is updated.

              If  DIR  is  a  relative path, it is relative to the destination
              directory.  See also --compare-dest and --copy-dest.

              Note that rsync versions prior to 2.6.1 had  a  bug  that  could
              prevent  --link-dest  from working properly for a non-super-user
              when -o was specified (or implied by -a).  You  can  work-around
              this bug by avoiding the -o option when sending to an old rsync.


       -z, --compress
              With this option, rsync compresses the file data as it  is  sent
              to  the  destination  machine,  which reduces the amount of data
              being transmitted -- something that is useful over a  slow  con-
              nection.

              Note  that  this  option  typically  achieves better compression
              ratios than can be achieved by using a compressing remote  shell
              or  a  compressing  transport  because it takes advantage of the
              implicit information in the matching data blocks  that  are  not
              explicitly sent over the connection.

              See the --skip-compress option for the default list of file suf-
              fixes that will not be compressed.


       --compress-level=NUM
              Explicitly set the compression level  to  use  (see  --compress)
              instead  of  letting it default.  If NUM is non-zero, the --com-
              press option is implied.


       --skip-compress=LIST
              Override the list of file suffixes that will not be  compressed.
              The  LIST  should be one or more file suffixes (without the dot)
              separated by slashes (/).

              You may specify an empty string to indicate that no file  should
              be skipped.

              Simple  character-class matching is supported: each must consist
              of a list of letters inside the square brackets (e.g. no special
              classes, such as "[:alpha:]", are supported).

              The  characters  asterisk (*) and question-mark (?) have no spe-
              cial meaning.

              Here's an example that specifies 6 suffixes to skip (since 1  of
              the 5 rules matches 2 suffixes):

                  --skip-compress=gz/jpg/mp[34]/7z/bz2


              The default list of suffixes that will not be compressed is this
              (several of these are newly added for 3.0.0):

                  gz/zip/z/rpm/deb/iso/bz2/t[gb]z/7z/mp[34]/mov/avi/ogg/jpg/jpeg


              This list will be replaced by your --skip-compress list  in  all
              but  one  situation:  a  copy  from a daemon rsync will add your
              skipped suffixes to its list of non-compressing files  (and  its
              list may be configured to a different default).


       --numeric-ids
              With  this option rsync will transfer numeric group and user IDs
              rather than using user and group names and mapping them at  both
              ends.

              By  default  rsync will use the username and groupname to deter-
              mine what ownership to give files. The special  uid  0  and  the
              special  group  0  are never mapped via user/group names even if
              the --numeric-ids option is not specified.

              If a user or group has no name on the source system or it has no
              match  on  the  destination system, then the numeric ID from the
              source system is used instead.  See also  the  comments  on  the
              "use  chroot" setting in the rsyncd.conf manpage for information
              on how the chroot setting affects rsync's ability to look up the
              names of the users and groups and what you can do about it.


       --timeout=TIMEOUT
              This  option allows you to set a maximum I/O timeout in seconds.
              If no data is transferred for the specified time then rsync will
              exit. The default is 0, which means no timeout.


       --contimeout
              This option allows you to set the amount of time that rsync will
              wait for its connection to an rsync daemon to succeed.   If  the
              timeout is reached, rsync exits with an error.


       --address
              By default rsync will bind to the wildcard address when connect-
              ing to an rsync daemon.  The  --address  option  allows  you  to
              specify  a  specific  IP  address (or hostname) to bind to.  See
              also this option in the --daemon mode section.


       --port=PORT
              This specifies an alternate TCP port number to use  rather  than
              the  default  of  873.  This is only needed if you are using the
              double-colon (::) syntax to connect with an rsync daemon  (since
              the  URL  syntax  has a way to specify the port as a part of the
              URL).  See also this option in the --daemon mode section.


       --sockopts
              This option can provide endless fun for people who like to  tune
              their  systems  to  the  utmost degree. You can set all sorts of
              socket options which may make  transfers  faster  (or  slower!).
              Read  the  man page for the setsockopt() system call for details
              on some of the options you may be able to  set.  By  default  no
              special  socket options are set. This only affects direct socket
              connections to a remote rsync daemon.  This option  also  exists
              in the --daemon mode section.


       --blocking-io
              This  tells  rsync  to  use blocking I/O when launching a remote
              shell transport.  If the remote shell is either  rsh  or  remsh,
              rsync  defaults  to using blocking I/O, otherwise it defaults to
              using non-blocking I/O.  (Note  that  ssh  prefers  non-blocking
              I/O.)


       -i, --itemize-changes
              Requests  a  simple  itemized list of the changes that are being
              made to each file, including attribute changes.  This is exactly
              the  same  as  specifying --out-format='%i %n%L'.  If you repeat
              the option, unchanged files will also be output, but only if the
              receiving  rsync is at least version 2.6.7 (you can use -vv with
              older versions of rsync, but that also turns on  the  output  of
              other verbose messages).

              The  "%i"  escape  has a cryptic output that is 11 letters long.
              The general format is like the string YXcstpoguax,  where  Y  is
              replaced  by the type of update being done, X is replaced by the
              file-type, and the other letters represent attributes  that  may
              be output if they are being modified.

              The update types that replace the Y are as follows:


              o      A  < means that a file is being transferred to the remote
                     host (sent).

              o      A > means that a file is being transferred to  the  local
                     host (received).

              o      A  c  means that a local change/creation is occurring for
                     the item (such as the creation  of  a  directory  or  the
                     changing of a symlink, etc.).

              o      A  h  means  that the item is a hard link to another item
                     (requires --hard-links).

              o      A . means that the item is not being updated  (though  it
                     might have attributes that are being modified).

              o      A  * means that the rest of the itemized-output area con-
                     tains a message (e.g. "deleting").


              The file-types that replace the X are: f for a file, a d  for  a
              directory,  an  L for a symlink, a D for a device, and a S for a
              special file (e.g. named sockets and fifos).

              The other letters in the string above  are  the  actual  letters
              that  will be output if the associated attribute for the item is
              being updated or a "." for no change.  Three exceptions to  this
              are:  (1)  a newly created item replaces each letter with a "+",
              (2) an identical item replaces the dots with spaces, and (3)  an
              unknown attribute replaces each letter with a "?" (this can hap-
              pen when talking to an older rsync).

              The attribute that is associated with each letter is as follows:


              o      A  c  means  either  that  a regular file has a different
                     checksum (requires --checksum) or that a symlink, device,
                     or  special  file  has a changed value.  Note that if you
                     are sending files to an rsync prior to 3.0.1, this change
                     flag  will be present only for checksum-differing regular
                     files.

              o      A s means the size of a regular  file  is  different  and
                     will be updated by the file transfer.

              o      A t means the modification time is different and is being
                     updated to the sender's  value  (requires  --times).   An
                     alternate  value  of  T  means that the modification time
                     will be set to the transfer time, which  happens  when  a
                     file/symlink/device is updated without --times and when a
                     symlink is changed and the receiver can't set  its  time.
                     (Note:  when  using  an rsync 3.0.0 client, you might see
                     the s flag combined with t instead of the proper  T  flag
                     for this time-setting failure.)

              o      A  p  means  the  permissions are different and are being
                     updated to the sender's value (requires --perms).

              o      An o means the owner is different and is being updated to
                     the sender's value (requires --owner and super-user priv-
                     ileges).

              o      A g means the group is different and is being updated  to
                     the sender's value (requires --group and the authority to
                     set the group).

              o      The u slot is reserved for future use.

              o      The a means that the ACL information changed.

              o      The x  means  that  the  extended  attribute  information
                     changed.


              One  other  output  is  possible:  when deleting files, the "%i"
              will output the string "*deleting" for each item that  is  being
              removed  (assuming that you are talking to a recent enough rsync
              that it logs deletions instead of outputting them as  a  verbose
              message).


       --out-format=FORMAT
              This allows you to specify exactly what the rsync client outputs
              to the user on a per-update basis.  The format is a text  string
              containing  embedded  single-character escape sequences prefixed
              with a percent (%) character.  For a list of the possible escape
              characters, see the "log format" setting in the rsyncd.conf man-
              page.

              Specifying this option will mention each file,  dir,  etc.  that
              gets  updated in a significant way (a transferred file, a recre-
              ated symlink/device, or a touched directory).  In  addition,  if
              the  itemize-changes  escape (%i) is included in the string, the
              logging of names increases to mention any item that  is  changed
              in  any  way  (as long as the receiving side is at least 2.6.4).
              See the --itemize-changes option for a description of the output
              of "%i".

              The --verbose option implies a format of "%n%L", but you can use
              --out-format without --verbose if you like, or you can  override
              the format of its per-file output using this option.

              Rsync will output the out-format string prior to a file's trans-
              fer unless one of the transfer-statistic escapes  is  requested,
              in  which  case  the  logging  is  done at the end of the file's
              transfer.  When this late logging is in effect and --progress is
              also  specified,  rsync  will  also  output the name of the file
              being transferred prior to its progress  information  (followed,
              of course, by the out-format output).


       --log-file=FILE
              This  option  causes  rsync  to  log what it is doing to a file.
              This is similar to the logging that a daemon does,  but  can  be
              requested  for  the client side and/or the server side of a non-
              daemon transfer.  If specified as a client option, transfer log-
              ging  will  be  enabled with a default format of "%i %n%L".  See
              the --log-file-format option if you wish to override this.

              Here's a example command that requests the remote  side  to  log
              what is happening:

                rsync -av --rsync-path="rsync --log-file=/tmp/rlog" src/ dest/


              This  is  very  useful  if you need to debug why a connection is
              closing unexpectedly.


       --log-file-format=FORMAT
              This allows you to specify exactly what  per-update  logging  is
              put into the file specified by the --log-file option (which must
              also be specified for this option to have any effect).   If  you
              specify  an empty string, updated files will not be mentioned in
              the log file.  For a list of the possible escape characters, see
              the "log format" setting in the rsyncd.conf manpage.


       --stats
              This  tells  rsync  to  print a verbose set of statistics on the
              file transfer, allowing you to tell how effective rsync's delta-
              transfer algorithm is for your data.

              The current statistics are as follows:

              o      Number  of  files  is  the  count  of all "files" (in the
                     generic sense),  which  includes  directories,  symlinks,
                     etc.

              o      Number  of files transferred is the count of normal files
                     that were updated via rsync's  delta-transfer  algorithm,
                     which does not include created dirs, symlinks, etc.

              o      Total file size is the total sum of all file sizes in the
                     transfer.  This does not count any size  for  directories
                     or  special files, but does include the size of symlinks.

              o      Total transferred file size is the total sum of all files
                     sizes for just the transferred files.

              o      Literal  data  is  how much unmatched file-update data we
                     had to send to  the  receiver  for  it  to  recreate  the
                     updated files.

              o      Matched  data  is  how much data the receiver got locally
                     when recreating the updated files.

              o      File list size is how big the file-list data was when the
                     sender sent it to the receiver.  This is smaller than the
                     in-memory size for the file list due to some  compressing
                     of duplicated data when rsync sends the list.

              o      File  list  generation time is the number of seconds that
                     the sender spent creating the file list.  This requires a
                     modern  rsync on the sending side for this to be present.

              o      File list transfer time is the number of seconds that the
                     sender spent sending the file list to the receiver.

              o      Total bytes sent is the count of all the bytes that rsync
                     sent from the client side to the server side.

              o      Total bytes received is  the  count  of  all  non-message
                     bytes  that  rsync  received  by the client side from the
                     server side.  "Non-message" bytes  means  that  we  don't
                     count  the  bytes  for  a verbose message that the server
                     sent to us, which makes the stats more consistent.



       -8, --8-bit-output
              This tells rsync to leave all high-bit characters  unescaped  in
              the  output  instead  of