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

-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  directories
       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 transfer  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-recursive option or its shorter  --no-i-r
       alias.

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

-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 directory.

              Thus,  when --perms and --executability are both disabled, rsync’s behavior is the same as that of
              other file-copy utilities, 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 destination-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-created 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.)

-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).

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

-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 transferred
       and  a  brief summary at the end. Two -v options will give you information on what files are being
       skipped and slightly more information at the end. More than two -v options 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 mention 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.

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