neulab/tldr huggingface dataset:
NEWGRP(1)                         User Commands                        NEWGRP(1)
newgrp - log in to a new group
newgrp [group]
newgrp changes the group identification of its caller, analogously to login(1). The same person remains logged in, and the current directory is unchanged, but calculations of access permissions to files are performed with respect to the new group ID.
If no group is specified, the GID is changed to the login GID.
/etc/group, /etc/passwd
Originally by Michael Haardt. Currently maintained by Peter Orbaek <poe@daimi.aau.dk>.
login(1), group(5)
The newgrp command is part of the util-linux package which can be downloaded from Linux Kernel Archive <https://www.kernel.org/pub/linux/utils/util-linux/>.
NSLOOKUP(1)                          BIND 9                          NSLOOKUP(1)
nslookup - query Internet name servers interactively
nslookup [-option] [name | -] [server]
nslookup is a program to query Internet domain name servers.  nslookup has two modes: interactive and non-interactive. Interactive mode allows the user to query name servers for information about various hosts and domains or to print a list of hosts in a domain.  Non-interactive mode prints just the name and requested information for a host or domain.
Interactive mode is entered in the following cases:
a. when no arguments are given (the default name server is used);
b. when the first argument is a hyphen (-) and the second argument is the host name or Internet address of a name server.
Non-interactive mode is used when the name or Internet address of the host to be looked up is given as the first argument. The optional second argument specifies the host name or address of a name server.
Options can also be specified on the command line if they precede the arguments and are prefixed with a hyphen. For example, to change the default query type to host information, with an initial timeout of 10 seconds, type:
nslookup -query=hinfo  -timeout=10
The -version option causes nslookup to print the version number and immediately exit.
host [server] This command looks up information for host using the current default server or using server, if specified. If host is an Internet address and the query type is A or PTR, the name of the host is returned. If host is a name and does not have a trailing period (.), the search list is used to qualify the name.
To look up a host not in the current domain, append a period to the name.
server domain | lserver domain These commands change the default server to domain; lserver uses the initial server to look up information about domain, while server uses the current default server. If an authoritative answer cannot be found, the names of servers that might have the answer are returned.
root   This command is not implemented.
finger This command is not implemented.
ls     This command is not implemented.
view   This command is not implemented.
help   This command is not implemented.
?      This command is not implemented.
exit   This command exits the program.
set keyword[=value] This command is used to change state information that affects the lookups. Valid keywords are:
all    This keyword prints the current values of the frequently used options to set. Information about the current default server and host is also printed.
class=value This keyword changes the query class to one of:
IN     the Internet class
CH     the Chaos class
HS     the Hesiod class
ANY    wildcard
The class specifies the protocol group of the information. The default is IN; the abbreviation for this keyword is cl.
nodebug This keyword turns on or off the display of the full response packet, and any intermediate response packets, when searching. The default for this keyword is nodebug; the abbreviation for this keyword is [no]deb.
nod2   This keyword turns debugging mode on or off. This displays more about what nslookup is doing. The default is nod2.
domain=name This keyword sets the search list to name.
nosearch If the lookup request contains at least one period, but does not end with a trailing period, this keyword appends the domain names in the domain search list to the request until an answer is received. The default is search.
port=value This keyword changes the default TCP/UDP name server port to value from its default, port 53. The abbreviation for this keyword is po.
querytype=value | type=value This keyword changes the type of the information query to value. The defaults are A and then AAAA; the abbreviations for these keywords are q and ty.
Please note that it is only possible to specify one query type. Only the default behavior looks up both when an alternative is not specified.
norecurse This keyword tells the name server to query other servers if it does not have the information. The default is recurse; the abbreviation for this keyword is [no]rec.
ndots=number This keyword sets the number of dots (label separators) in a domain that disables searching. Absolute names always stop searching.
retry=number This keyword sets the number of retries to number.
timeout=number This keyword changes the initial timeout interval to wait for a reply to number, in seconds.
novc   This keyword indicates that a virtual circuit should always be used when sending requests to the server.  novc is the default.
nofail This keyword tries the next nameserver if a nameserver responds with SERVFAIL or a referral (nofail), or terminates the query (fail) on such a response. The default is nofail.
nslookup returns with an exit status of 1 if any query failed, and 0 otherwise.
If nslookup has been built with IDN (internationalized domain name) support, it can accept and display non-ASCII domain names. nslookup appropriately converts character encoding of a domain name before sending a request to a DNS server or displaying a reply from the server.  To turn off IDN support, define the IDN_DISABLE environment variable. IDN support is disabled if the variable is set when nslookup runs, or when the standard output is not a tty.
dig(1), host(1), named(8).
LOLCAT(6)                         Games Manual                         LOLCAT(6)
lolcat - rainbow coloring effect for text console display
lolcat [options] [files] ...
This manual page documents briefly the lolcat command.
lolcat is a program that concatenates files, or standard input, to standard output (like the generic cat), and adds rainbow coloring to it.
-p X, --spread=X Inclination of the rainbow stripes (character widths per line hight; high values (>1000) give almost horizonal stripes, low values (0.1) almost vertical ones; default: 3.0).
-F X, --freq=X Frequency of the rainbow effect. (low values around 0.0001 give almost monochromous screens; default: 0.1).
-S X, --seed=X Initial value for the random number generator; 0 means automatic. (default: 0).
-a, --animate Fade every line through an animation before printing the next one.
-d X, --duration=X Duration of the animation. (number of steps before showing next line; default: 12)
-s X, --speed=X Speed of the animation. (frame rate, ie. number of steps per second; default: 20)
-i, --invert Inverts the background and foreground colors.
-t, --truecolor Enables 24-bit truecolor mode.
-f, --force Force color even when stdout is not a tty.
-v, --version Shows lolcat version.
-h, --help Shows options summary.
Typical combinations of lolcat include other programs that generate text: Large colorful words can be written like this:
echo "KTHXBAI" | toilet | lolcat
Cows are popular, come in all colors, and tell random epigrams:
fortune | cowsay | lolcat -a
cat(1), toilet(1), fortune(6), cowsay(6)
lolcat was written by Moe <moe@busyloop.net>.
This manual page was originally written by chrysn <chrysn@fsfe.org>, for the Debian project. Very quickly revamped by Mathieu Aubin <mathieu@zeroserieux.com> to include as part of official code repository.
rsync(1)                          User Commands                         rsync(1)
rsync - a fast, versatile, remote (and local) file-copying tool
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.
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 permissions
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)
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 transport 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 destination, 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).
Rsync refers to the local side as the client and the remote side as the server.  Don't confuse server with an rsync daemon.  A daemon is always a server, but a server can be either a daemon or a remote-shell spawned process.
See the file README.md 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 different 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.
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 protocol is used to update the file by sending only the differences in the data. Note that the expansion of wildcards on the command-line (*.c) into a list of files is handled by the shell before it runs rsync and not by rsync itself (exactly the same as all other Posix-style programs).
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 symbolic 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 containing directory on the destination.  In other words, each of the following 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 particular rsync daemon by leaving off the module name:
rsync somehost.mydomain.com::
See the following section for more details.
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
It is also possible to use rsync without a remote shell as the transport. 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 DAEMON 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 connect.
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 specified files on the remote daemon is provided.
o      you must not specify the --rsh (-e) option (since that overrides the daemon connection to use ssh -- see USING RSYNC-DAEMON FEATURES VIA A REMOTE-SHELL CONNECTION below).
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 environment 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 targethost (%H).
Note also that if the RSYNC_SHELL environment variable is set, that program will be used to run the RSYNC_CONNECT_PROG command instead of using the default shell of the system() call.
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 connection uses nearly the same command-line syntax as a normal rsync- daemon 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".
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 handling 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 configurations).
If you're using one of the remote-shell transports for the transfer, there is no need to manually start an rsync daemon.
Rsync always sorts the specified filenames into its internal transfer list.  This handles the merging together of the contents of identically named directories, makes it easy to remove duplicate filenames, and may confuse someone when the files are transferred in a different order than what was given on the command-line.
If you need a particular file to be transferred prior to another, either separate the files into different rsync calls, or consider using --delay- updates (which doesn't affect the sorted transfer order, but does make the final file-updating phase happen much more rapidly).
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 targets:
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 command:
rsync -az -e ssh --delete ~ftp/pub/samba nimbus:"~ftp/pub/tridge"
This is launched from cron every few hours.
Here is a short summary of the options available in rsync.  Please refer to the detailed description below for a complete description.
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=RATE           limit socket I/O bandwidth --config=FILE            specify alternate rsyncd.conf file --dparam=OVERRIDE, -M    override global daemon config parameter --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 --verbose, -v            increase verbosity --ipv4, -4               prefer IPv4 --ipv6, -6               prefer IPv6 --help, -h               show this help (when used with --daemon)
Rsync accepts both long (double-dash + word) and short (single-dash + letter) options.  The full list of the available options are described below.  If an option can be specified in more than one way, the choices are comma-separated.  Some options only have a long variant, not a short. If the option takes a parameter, the parameter is only listed after the long variant, even though it must also be specified for the short.  When specifying a parameter, you can either use the form --option=param or replace the '=' with whitespace.  The parameter may need to be quoted in some manner for it to survive the shell's command-line parsing.  Keep in mind that a leading tilde (~) in a filename is substituted by your shell, so --option=~/foo will not change the tilde into your home directory (remove the '=' for that).
--help, -h (*) Print a short help page describing the options available in rsync and exit.  (*) The -h short option will only invoke --help when used without other options since it normally means --human- readable.
--version, -V Print the rsync version plus other info and exit.
The output includes the default list of checksum algorithms, the default list of compression algorithms, a list of compiled-in capabilities, a link to the rsync web site, and some license/copyright info.
--verbose, -v 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.
In a modern rsync, the -v option is equivalent to the setting of groups of --info and --debug options.  You can choose to use these newer options in addition to, or in place of using --verbose, as any fine-grained settings override the implied settings of -v. Both --info and --debug have a way to ask for help that tells you exactly what flags are set for each increase in verbosity.
However, do keep in mind that a daemon's "max verbosity" setting will limit how high of a level the various individual flags can be set on the daemon side.  For instance, if the max is 2, then any info and/or debug flag that is set to a higher value than what would be set by -vv will be downgraded to the -vv level in the daemon's logging.
--info=FLAGS This option lets you have fine-grained control over the information output you want to see.  An individual flag name may be followed by a level number, with 0 meaning to silence that output, 1 being the default output level, and higher numbers increasing the output of that flag (for those that support higher levels).  Use --info=help to see all the available flag names, what they output, and what flag names are added for each increase in the verbose level.  Some examples:
rsync -a --info=progress2 src/ dest/ rsync -avv --info=stats2,misc1,flist0 src/ dest/
Note that --info=name's output is affected by the --out-format and --itemize-changes (-i) options.  See those options for more information on what is output and when.
This option was added to 3.1.0, so an older rsync on the server side might reject your attempts at fine-grained control (if one or more flags needed to be send to the server and the server was too old to understand them).  See also the "max verbosity" caveat above when dealing with a daemon.
--debug=FLAGS This option lets you have fine-grained control over the debug output you want to see.  An individual flag name may be followed by a level number, with 0 meaning to silence that output, 1 being the default output level, and higher numbers increasing the output of that flag (for those that support higher levels).  Use --debug=help to see all the available flag names, what they output, and what flag names are added for each increase in the verbose level.  Some examples:
rsync -avvv --debug=none src/ dest/ rsync -avA --del --debug=del2,acl src/ dest/
Note that some debug messages will only be output when --stderr=all is specified, especially those pertaining to I/O and buffer debugging.
Beginning in 3.2.0, this option is no longer auto-forwarded to the server side in order to allow you to specify different debug values for each side of the transfer, as well as to specify a new debug option that is only present in one of the rsync versions. If you want to duplicate the same option on both sides, using brace expansion is an easy way to save you some typing.  This works in zsh and bash:
rsync -aiv {-M,}--debug=del2 src/ dest/
--stderr=errors|all|client This option controls which processes output to stderr and if info messages are also changed to stderr.  The mode strings can be abbreviated, so feel free to use a single letter value.  The 3 possible choices are:
o      errors - (the default) causes all the rsync processes to send an error directly to stderr, even if the process is on the remote side of the transfer.  Info messages are sent to the client side via the protocol stream.  If stderr is not available (i.e. when directly connecting with a daemon via a socket) errors fall back to being sent via the protocol stream.
o      all - causes all rsync messages (info and error) to get written directly to stderr from all (possible) processes. This causes stderr to become line-buffered (instead of raw) and eliminates the ability to divide up the info and error messages by file handle.  For those doing debugging or using several levels of verbosity, this option can help to avoid clogging up the transfer stream (which should prevent any chance of a deadlock bug hanging things up).  It also enables the outputting of some I/O related debug messages.
o      client - causes all rsync messages to be sent to the client side via the protocol stream.  One client process outputs all messages, with errors on stderr and info messages on stdout.  This was the default in older rsync versions, but can cause error delays when a lot of transfer data is ahead of the messages.  If you're pushing files to an older rsync, you may want to use --stderr=all since that idiom has been around for several releases.
This option was added in rsync 3.2.3.  This version also began the forwarding of a non-default setting to the remote side, though rsync uses the backward-compatible options --msgs2stderr and --no- msgs2stderr to represent the all and client settings, respectively.  A newer rsync will continue to accept these older option names to maintain compatibility.
--quiet, -q This option decreases the amount of information you are given during the transfer, notably suppressing information messages from the remote server.  This option 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.
--ignore-times, -I 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=NUM, -@ When comparing two timestamps, rsync treats the timestamps as being equal if they differ by no more than the modify-window value.  The default is 0, which matches just integer seconds.  If you specify a negative value (and the receiver is at least version 3.1.3) then nanoseconds will also be taken into account. Specifying 1 is useful for copies to/from MS Windows FAT filesystems, because FAT represents times with a 2-second resolution (allowing times to differ from the original by up to 1 second).
If you want all your transfers to default to comparing nanoseconds, you can create a ~/.popt file and put these lines in it:
rsync alias -a -a@-1 rsync alias -t -t@-1
With that as the default, you'd need to specify --modify-window=0 (aka -@0) to override it and ignore nanoseconds, e.g. if you're copying between ext3 and ext4, or if the receiving rsync is older than 3.1.3.
--checksum, -c 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 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, so this can slow things down significantly (and this is prior to any reading that will be done to transfer changed files)
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 transferred, 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.
The checksum used is auto-negotiated between the client and the server, but can be overridden using either the --checksum-choice (--cc) option or an environment variable that is discussed in that option's section.
--archive, -a 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 multiply-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 circumstances (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).
--recursive, -r 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.
--relative, -R Use relative paths.  This means that the full path names specified 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/
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 elements 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 symlink 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.) 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 commands.) 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 transfer.  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 differences, 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 transferred as normal directories.
--backup, -b 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 forced on, 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 "P *~").  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 This implies the --backup option, and tells rsync to store all backups in the specified directory on the receiving side.  This can be used for incremental backups.  You can additionally specify a backup suffix using the --suffix option (otherwise the files backed up in the specified directory will keep their original filenames).
Note that if you specify a relative path, the backup directory will be relative to the destination directory, so you probably want to specify either an absolute path or a path that starts with "../".  If an rsync daemon is the receiver, the backup dir cannot go outside the module's path hierarchy, so take extra care not to delete it or copy into it.
--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.
--update, -u This forces rsync to skip any files which exist on the destination 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 dirs, 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.
This option is a transfer rule, not an exclude, so it doesn't affect the data that goes into the file-lists, and thus it doesn't affect deletions.  It just limits the files that the receiver requests to be transferred.
--inplace This option changes how rsync transfers a file when its data needs to be updated: instead of the default method of creating 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:
o      Hard links are not broken.  This means the new data will be visible through other hard links to the destination file. Moreover, attempts to copy differing source files onto a multiply-linked destination file will result in a "tug of war" with the destination data changing back and forth.
o      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).
o      The file's data will be in an inconsistent state during the transfer and will be left that way if the transfer is interrupted or if an update fails.
o      A file that rsync cannot write to cannot be updated.  While a super user can update any file, a normal user needs to be granted write permission for the open of the file for writing to be successful.
o      The efficiency of rsync's delta-transfer algorithm may be reduced if some data in the destination file is overwritten before it can be copied to a position later in the file. This does not apply if you use --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 transferring large files with block- based changes or appended data, and also on systems that are disk bound, not network bound.  It can also help keep a copy-on-write filesystem snapshot from diverging the entire contents of a file that only has minor changes.
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 incompatible with --compare-dest and --link-dest.
--append This special copy mode only works to efficiently update files that are known to be growing larger where any existing content on the receiving side is also known to be the same as the content on the sender.  The use of --append can be dangerous if you aren't 100% sure that all the files in the transfer are shared, growing files. You should thus use filter rules to ensure that you weed out any files that do not fit this criteria.
Rsync updates these growing file in-place without verifying any of the existing content in the file (it only verifies the content that it is appending).  Rsync skips any files that exist on the receiving side that are not shorter than the associated file on the sending side (which means that new files are trasnferred).
This does not interfere with the updating of a file's non-content attributes (e.g.  permissions, ownership, etc.) when the file does not need to be transferred, nor does it affect the updating of any directories or non-regular files.
--append-verify This special copy mode works like --append except that all the data in the file is included in the checksum verification (making it much less efficient but also potentially safer).  This option can be dangerous if you aren't 100% sure that all the files in the transfer are shared, growing files.  See the --append option for more details.
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.
--dirs, -d 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 directories 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 directory without recursing.
--mkpath Create a missing path component of the destination arg.  This allows rsync to create multiple levels of missing destination dirs and to create a path in which to put a single renamed file.  Keep in mind that you'll need to supply a trailing slash if you want the entire destination path to be treated as a directory when copying a single arg (making rsync behave the same way that it would if the path component of the destination had already existed).
For example, the following creates a copy of file foo as bar in the sub/dir directory, creating dirs "sub" and "sub/dir" if either do not yet exist:
rsync -ai --mkpath foo sub/dir/bar
If you instead ran the following, it would have created file foo in the sub/dir/bar directory:
rsync -ai --mkpath foo sub/dir/bar/
--links, -l When symlinks are encountered, recreate the symlink on the destination.
--copy-links, -L 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 directories.  In a modern rsync such as this one, you'll need to specify --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.
Note that the cut-off point is the top of the transfer, which is the part of the path that rsync isn't mentioning in the verbose output.  If you copy "/src/subdir" to "/dest/" then the "subdir" directory is a name inside the transfer tree, not the top of the transfer (which is /src) so it is legal for created relative symlinks to refer to other names inside the /src and /dest directories.  If you instead copy "/src/subdir/" (with a trailing slash) to "/dest/subdir" that would not allow symlinks to any files outside of "subdir".
--safe-links This tells rsync to ignore any symbolic links which point outside the copied tree.  All absolute symlinks are also ignored. Using this option in conjunction with --relative may give unexpected results.