TapTap
36fd0774e8
- plain --delete with no timing flag now selects delete-during (progressive deletion, matching rsync and avoiding the full old+new tree peak) - new long-only FastSync --delete-commit restores the old atomic behavior (delete only after the whole transfer succeeds); timing-identical to --delete-after, implemented via the same wire bool - timing flags are mutually exclusive; --delete-commit conflicts with other timings; --delete-before/--delete-during rows reworded per Phase-0 probes - CHANGELOG migration note; tally unchanged 116/14/27
369 lines
28 KiB
C
369 lines
28 KiB
C
#include "usage.h"
|
|
#include <stdio.h>
|
|
#include <delta.h>
|
|
#include <chunk.h>
|
|
#include "scanner.h"
|
|
|
|
void print_usage(void) {
|
|
printf("Usage:\n");
|
|
printf(" fastsync [options] <source> <destination>\n");
|
|
printf(" fastsync [options] --source-dir <src> --dest-dir <dst>\n");
|
|
printf("\n");
|
|
printf("Destination formats:\n");
|
|
printf(" user@host:/path SSH transport (rsync-style)\n");
|
|
printf(" host:/path SSH transport (current user)\n");
|
|
printf(" host::module/path Daemon TCP transport (fastsync-server --daemon);\n");
|
|
printf(" module names a server-side module, path is relative\n");
|
|
printf(" within it (connect with --server-port)\n");
|
|
printf(" /local/path TCP transport (requires server on localhost:8080)\n");
|
|
printf("\n");
|
|
printf("Options:\n");
|
|
printf(" -c, --checksum Verify content by checksum instead of size+mtime\n");
|
|
printf(" -z, --compress [level] Enable compression (level 1-22, default 5)\n");
|
|
printf(" -a, --archive rsync archive mode (-rlptgoD): links, perms, times,\n");
|
|
printf(" owner, group, devices and specials; not\n");
|
|
printf(" compression/multithreading\n");
|
|
printf(" -r, --recursive Recurse into directories (FastSync is always recursive)\n");
|
|
printf(" -n, --dry-run Show what would be transferred\n");
|
|
printf(" --remove-source-files Remove regular source files after successful transfer\n");
|
|
printf(" -p, --perms Preserve permission bits\n");
|
|
printf(" -t, --times Preserve modification times\n");
|
|
printf(" -o, --owner Preserve owner (uid)\n");
|
|
printf(" -g, --group Preserve group (gid)\n");
|
|
printf(" --ssh-port <port> SSH port (default: 22)\n");
|
|
printf(" -e, --rsh <command> Remote shell to launch on the client for the SSH\n");
|
|
printf(" transport (default: ssh). The command may include\n");
|
|
printf(" arguments, e.g. -e \"ssh -p 2222\"\n");
|
|
printf(" --rsync-path <path> Alias for --fastsync-server-path (path to the\n");
|
|
printf(" fastsync server binary on the remote side)\n");
|
|
printf(" --blocking-io Leave the SSH transport socket without read/write\n");
|
|
printf(" timeouts so it blocks naturally\n");
|
|
printf(" --outbuf=MODE stdout/stderr buffering: N (none/unbuffered),\n");
|
|
printf(" L (line-buffered), or B (block-buffered, default)\n");
|
|
printf(" --progress Show transfer progress\n");
|
|
printf(" -P Partial mode with progress (retention incomplete)\n");
|
|
printf(" -8, --8-bit-output Leave high-bit characters unescaped in output\n");
|
|
printf(" --iconv=LOCAL[,REMOTE] Convert file-NAME charsets at the wire boundary:\n");
|
|
printf(" LOCAL is the charset of our file names, REMOTE is the\n");
|
|
printf(" remote side's charset (defaults to LOCAL). Names are\n");
|
|
printf(" converted before transmission and back on receipt; a\n");
|
|
printf(" name that cannot be represented in the target charset\n");
|
|
printf(" fails that transfer cleanly (rsync-compatible)\n");
|
|
printf(" --protocol=NUM Force the wire protocol version (must equal the current\n");
|
|
printf(" PROTOCOL_VERSION; FastSync cannot speak older/virtual\n");
|
|
printf(" wire formats)\n");
|
|
printf(" --write-batch=FILE Run the normal live transfer AND also emit a\n");
|
|
printf(" self-contained batch file of the whole source tree\n");
|
|
printf(" (implies the single-threaded transfer path)\n");
|
|
printf(" --only-write-batch=FILE\n");
|
|
printf(" Emit the batch file only (no destination, no server)\n");
|
|
printf(" --read-batch=FILE Apply the batch file to the destination (no source, no\n");
|
|
printf(" server); takes only the destination as an argument\n");
|
|
printf(" NOTE: the FastSync batch format is NOT interoperable with rsync's batch\n");
|
|
printf(" files (different container format); do not mix the two tools.\n");
|
|
printf(" --delete Delete files on receiver not in source\n");
|
|
printf(" (default timing: delete-during, like rsync --del)\n");
|
|
printf(" --delete-before Delete extras before the transfer starts\n");
|
|
printf(" (implies --delete)\n");
|
|
printf(" --delete-during Delete a directory's extras as that directory is\n");
|
|
printf(" processed (implies --delete)\n");
|
|
printf(" --del Alias for --delete-during\n");
|
|
printf(" --delete-delay Record the extras during the scan but remove them\n");
|
|
printf(" only after a successful transfer (implies --delete)\n");
|
|
printf(" --delete-after Delete only after the whole transfer succeeded\n");
|
|
printf(" (implies --delete)\n");
|
|
printf(" --delete-commit FastSync-only: restore the late whole-tree commit\n");
|
|
printf(" (identical to --delete-after; implies --delete)\n");
|
|
printf(" --delete-excluded Also delete destination files that were excluded on\n");
|
|
printf(" the source (default protects them, matching rsync)\n");
|
|
printf(" --max-delete=NUM Delete at most NUM destination entries per run; if the\n");
|
|
printf(" extras exceed NUM, the rest are skipped and the run is\n");
|
|
printf(" reported as partial (exit 25, matching rsync). Only\n");
|
|
printf(" applies together with --delete\n");
|
|
printf(" --ignore-errors Continue (and still delete) when a source directory is\n");
|
|
printf(" unreadable during the scan, instead of aborting with no\n");
|
|
printf(" deletion\n");
|
|
printf(" --force A file may replace a destination directory by removing\n");
|
|
printf(" that (non-empty) directory first\n");
|
|
printf(" --ignore-missing-args A --files-from entry that does not exist under the\n");
|
|
printf(" source is silently skipped instead of failing the run\n");
|
|
printf(" --delete-missing-args Implies --ignore-missing-args; also deletes each missing\n");
|
|
printf(" entry's destination mirror receiver-side. Independent of\n");
|
|
printf(" --delete (it does not imply --delete; a non-empty directory\n");
|
|
printf(" mirror is removed only with --force or --delete)\n");
|
|
printf(" -m, --prune-empty-dirs Do not create empty directories (a recursive transfer\n");
|
|
printf(" otherwise recreates them, like rsync)\n");
|
|
printf(" Note: each timing flag implies --delete. Combining a timing flag with\n");
|
|
printf(" --no-delete (in either order) is rejected as a config error, as is more\n");
|
|
printf(" than one timing flag.\n");
|
|
printf(" --ignore-existing Skip files that already exist on receiver\n");
|
|
printf(" --delay-updates Put updated files into place only at the end of transfer\n");
|
|
printf(" --dirs, -d, --old-dirs, --old-d Transfer the named directory entries without\n");
|
|
printf(" recursing into their contents (-d <dir> mirrors the source\n");
|
|
printf(" directory empty; with --files-from listed dirs are created\n");
|
|
printf(" empty and listed files are transferred)\n");
|
|
printf(" -R, --relative With --files-from, preserve each listed entry's relative path\n");
|
|
printf(" below the destination root instead of mirroring the full\n");
|
|
printf(" source path (no effect without --files-from)\n");
|
|
printf(" --no-implied-dirs With -R, do not apply the source metadata of a listed file's\n");
|
|
printf(" implied parent directories (they are still created with\n");
|
|
printf(" default attributes)\n");
|
|
printf(" --mkpath Create the destination root directory on the server when it\n");
|
|
printf(" does not exist yet\n");
|
|
printf(" --exclude <pattern>, --exclude=<pattern> Exclude files matching pattern\n");
|
|
printf(" --include <pattern>, --include=<pattern> Only include files matching pattern\n");
|
|
printf(" --exclude-from <file>, --exclude-from=<file> Read exclude patterns from file\n");
|
|
printf(" --include-from <file>, --include-from=<file> Read include patterns from file\n");
|
|
printf(" --files-from <file> Read the source file list from FILE (paths relative to the "
|
|
"source root)\n");
|
|
printf(" -0, --from0 Entries in --files-from are NUL-delimited\n");
|
|
printf(" -f, --filter=RULE rsync-style filter rule: exclude/- include/+ hide/H show/S\n");
|
|
printf(" protect/P risk/R merge/. dir-merge/: clear/! with modifiers\n");
|
|
printf(" (repeatable; --filter=RULE and -f RULE / -f=RULE both work)\n");
|
|
printf(" -C, --cvs-exclude Auto-ignore common CVS/SCM files (.git/, .svn/, *.o, *~, ...)\n");
|
|
printf(" -F Apply per-directory .rsync-filter files; repeated -FF also\n");
|
|
printf(" excludes the .rsync-filter files themselves\n");
|
|
printf(" --max-size <n> Skip files larger than n bytes\n");
|
|
printf(" --min-size <n> Skip files smaller than n bytes\n");
|
|
printf(" --max-alloc <SIZE> Maximum single allocation (default: 1G; 0 = no limit,\n");
|
|
printf(" matching rsync)\n");
|
|
printf(" --incremental Skip files unchanged since last transfer\n");
|
|
printf(" --size-only Skip incremental files matching in size, ignoring mtime\n");
|
|
printf(" -I, --ignore-times Transfer files even when size and mtime match\n");
|
|
printf(" -@, --modify-window <sec> Modification time tolerance\n");
|
|
printf(" -u, --update Skip files newer than the source on receiver\n");
|
|
printf(" --existing Skip files not already present at destination\n");
|
|
printf(" --compare-dest <dir> Treat DIR (relative to destination root) as an extra\n");
|
|
printf(" comparison basis: unchanged files are not transferred\n");
|
|
printf(" (requires --incremental, which is implied)\n");
|
|
printf(" --copy-dest <dir> Like --compare-dest, but copies the unchanged file from DIR\n");
|
|
printf(" into the destination instead of transferring its data\n");
|
|
printf(" --link-dest <dir> Like --copy-dest, but hard-links the unchanged file from DIR\n");
|
|
printf(" into the destination (repeatable; earlier DIRs win)\n");
|
|
printf(" --verify-basis FastSync-only: require a basis hit's content to match the\n");
|
|
printf(" source by whole-file digest instead of trusting rsync's\n");
|
|
printf(" size+mtime (or --size-only) quick-check\n");
|
|
printf(" --checksum-choice, --cc <alg> Whole-file checksum algorithm for --incremental/\n");
|
|
printf(" --checksum compares. Accepted: xxh128 (default), xxh3, xxh64\n");
|
|
printf(" (aka xxhash), md5, md4, sha1, or none. A two-name\n");
|
|
printf(" 'transfer,pre-transfer' form is accepted like rsync; 'none' as\n");
|
|
printf(" the pre-transfer algorithm is rejected with --checksum\n");
|
|
printf(" --checksum-seed <num> Seed for the whole-file xxHash digest (and the delta\n");
|
|
printf(" block strong hash, low 32 bits); md5 ignores the seed. A seed\n");
|
|
printf(" of 0 (the default) is randomized per transfer, exactly like\n");
|
|
printf(" rsync, and the chosen seed is sent to the receiver\n");
|
|
printf(" --delta Delta transfer for changed files (requires --incremental)\n");
|
|
printf(" -W, --whole-file Transfer changed files without delta processing\n");
|
|
printf(" --no-whole-file rsync spelling that clears -W/--whole-file\n");
|
|
printf(" -y, --fuzzy Use a similar-named file already in the destination\n");
|
|
printf(" directory as the delta basis when the destination has no\n");
|
|
printf(" usable file at the exact path (saves bandwidth; implies\n");
|
|
printf(" --incremental and --delta; inert with --whole-file,\n");
|
|
printf(" --no-delta, or --no-incremental)\n");
|
|
printf(" --no-fuzzy Disable --fuzzy\n");
|
|
printf(" -B <n>, --block-size <n>, --delta-block <n>\n");
|
|
printf(" Delta block size in bytes (default: %d)\n", DELTA_BLOCK_SIZE_DEFAULT);
|
|
printf(" --delta-max <n> Max file size for delta transfer (default: %llu)\n",
|
|
DELTA_MAX_FILE_SIZE);
|
|
printf(" -j, --threads[=N] Enable the multithreaded scanner/loader/sender\n");
|
|
printf(" pipeline; N (1-%d) sets the parallel scanner worker\n",
|
|
MAX_SCANNER_THREADS);
|
|
printf(" count (bare -j/--threads uses the default)\n");
|
|
printf(" --chunk-serialization Enable chunk serialization (long form only)\n");
|
|
printf(" -s, --secluded-args Protect-args compatibility option (no effect; remote\n");
|
|
printf(" SSH argv is already built injection-safe)\n");
|
|
printf(" --sendfile Enable sendfile zero-copy (TCP only; long form only;\n");
|
|
printf(" -f is bound to --filter, not --sendfile)\n");
|
|
printf(" --compress-choice <alg> Compression algorithm: zstd (default), lz4, zlib,\n");
|
|
printf(" zlibx, none, or auto\n");
|
|
printf(" --zc <alg> Alias for --compress-choice\n");
|
|
printf(" -v, --verbose Enable debug logging\n");
|
|
printf(" -q, --quiet Suppress non-error output\n");
|
|
printf(" --debug=FLAGS Fine-grained debug logging (use --debug=help for flags)\n");
|
|
printf(" --info=FLAGS Fine-grained info: copy,name,misc,skip,stats,all,none\n");
|
|
printf(" (use --info=help for flags; none suppresses --verbose)\n");
|
|
printf(" --preserve Preserve permissions and times (= -pt; long form only)\n");
|
|
printf(" --no-perms Negate -p/--perms\n");
|
|
printf(" --no-times Negate -t/--times\n");
|
|
printf(" --no-owner Negate -o/--owner\n");
|
|
printf(" --no-group Negate -g/--group\n");
|
|
printf(" --no-preserve Disable metadata preservation (negates --preserve)\n");
|
|
printf(" -E, --executability Preserve executable permission bits\n");
|
|
printf(" -U, --atimes Preserve access times\n");
|
|
printf(" -N, --crtimes Capture birth time; cannot be applied (documented\n");
|
|
printf(" divergence)\n");
|
|
printf(" -X, --xattrs Preserve user extended attributes (user.* only;\n");
|
|
printf(" privileged security.*/trusted.* namespaces are\n");
|
|
printf(" never captured or applied)\n");
|
|
printf(" -A, --acls Preserve POSIX ACLs (the system.posix_acl_* xattrs;\n");
|
|
printf(" setting an ACL the receiver is not permitted to\n");
|
|
printf(" set is warned and skipped, never fatal)\n");
|
|
printf(" --fake-super Store the source uid/gid/mode/mtime in a reserved\n");
|
|
printf(" user.fastsync.stat xattr on each written file and\n");
|
|
printf(" re-apply it (fd-relative) on a privileged run; the\n");
|
|
printf(" recording format diverges from rsync's user.rsync.%%stat%%\n");
|
|
printf(" --super Permit the receiver to attempt super-user activities\n");
|
|
printf(" (char/block device-node creation, --write-devices)\n");
|
|
printf(" within the confined receive root. Never elevates\n");
|
|
printf(" privileges and never bypasses confinement; ownership\n");
|
|
printf(" is still applied only with -o/--owner, -g/--group, or an\n");
|
|
printf(" explicit identity flag (--chown/--usermap/--groupmap/\n");
|
|
printf(" --copy-as); --numeric-ids only changes how ids map\n");
|
|
printf(" --no-super Forbid those super-user activities even when the\n");
|
|
printf(" receiver is running as root\n");
|
|
printf(
|
|
" --chmod <changes> Modify new/transferred permissions (rsync syntax; implies no -p)\n");
|
|
printf(" --numeric-ids Map uid/gid by id instead of by name (a modifier, not\n");
|
|
printf(" an ownership request: combine with -o/-g or a map)\n");
|
|
printf(" --usermap=MAP Map usernames when applying ownership: comma-separated\n");
|
|
printf(" FROM:TO rules, first match wins. FROM is a name (from\n");
|
|
printf(" the source), an id, an inclusive LOW-HIGH range, *\n");
|
|
printf(" (any id), or empty (ids with no name). TO is an id, *\n");
|
|
printf(" (current user), or a name resolved on the receiver.\n");
|
|
printf(" e.g. 0-99:nobody,*:normal (cannot mix with --chown)\n");
|
|
printf(" --groupmap=MAP Map group names when applying ownership (same syntax)\n");
|
|
printf(" --chown=USER:GROUP Override the ownership of transferred files. Forms:\n");
|
|
printf(" USER:GROUP, USER (owner only), :GROUP (group only); a\n");
|
|
printf(" value of * means the current/root user as appropriate.\n");
|
|
printf(" Names resolve on the source machine; @N for numerics.\n");
|
|
printf(" (Implies owner/group metadata; -M now means rsync's\n");
|
|
printf(" --remote-option.)\n");
|
|
printf(" --copy-as=USER[:GROUP] Force every written entry (files, dirs, symlinks\n");
|
|
printf(" and special nodes) to USER[:GROUP], resolved on the\n");
|
|
printf(" source machine like --chown. Requires a privileged\n");
|
|
printf(" (root) receiver and implies owner/group metadata; an\n");
|
|
printf(" unprivileged receiver refuses the transfer. Never\n");
|
|
printf(" switches process credentials (safe-subset; see\n");
|
|
printf(" RSYNC_COMPAT.md). A daemon refuses it.\n");
|
|
printf(" --chunk-size <n> Chunk size in bytes (default: %d)\n", DEFAULT_CHUNK_SIZE);
|
|
printf(" --source-dir <path> Source directory\n");
|
|
printf(" --dest-dir <path> Destination directory\n");
|
|
printf(" --save-to-disk Write received files to disk\n");
|
|
printf(" --server-host <ip> Server IP address (default: 127.0.0.1)\n");
|
|
printf(" --server-port <n> Server port (default: 8080)\n");
|
|
printf(" --port <n> Alias for --server-port\n");
|
|
printf(" --password-file <f> Authenticate a host::module/path daemon destination.\n");
|
|
printf(" FastSync-native SCRAM/PBKDF2 credential scheme (NOT\n");
|
|
printf(" rsync's --password-file): the file's first user:password\n");
|
|
printf(" line supplies the username and password; no password or\n");
|
|
printf(" reusable digest is sent (keep the file mode 0600)\n");
|
|
printf(" --no-motd Suppress display of the daemon's MOTD (the server\n");
|
|
printf(" still sends it; the client just does not show it)\n");
|
|
printf(" --bwlimit=RATE Limit socket I/O bandwidth (default unit KiB/s,\n");
|
|
printf(" rsync-style: 0 = no limit; K/M/G/T/P suffixes are\n");
|
|
printf(" binary, KB/MB decimal, KiB/MiB binary; decimals allowed)\n");
|
|
printf(" --tls Enable TLS encryption\n");
|
|
printf(" --cert <path> TLS certificate file (PEM)\n");
|
|
printf(" --key <path> TLS private key file (PEM)\n");
|
|
printf(" --ca <path> TLS CA certificate file (PEM)\n");
|
|
printf(" --timeout <sec> I/O timeout in seconds (default: 0 = disabled, matching\n");
|
|
printf(" rsync). 0 disables it; --no-timeout is the same\n");
|
|
printf(" --contimeout <sec> Connection timeout in seconds (default: 60, matching\n");
|
|
printf(" rsync); 0 disables it (--no-contimeout)\n");
|
|
printf(" --stop-after=MINS Stop the transfer after MINS minutes (a positive\n");
|
|
printf(" integer); whatever was already transferred is kept\n");
|
|
printf(" --stop-at=TIME Stop at an absolute time. Accepts rsync's date form\n");
|
|
printf(" (Y-M-DTh:m, Y/M/DTh:m, abbreviable fields such as 12-31,\n");
|
|
printf(" 14:00, :59, 1) plus FastSync's HH:MM[:SS] and now+N[smhd]\n");
|
|
printf(" (a time already in the past stops the transfer\n");
|
|
printf(" immediately; client-only). An early stop skips the late\n");
|
|
printf(" --delete keep-set so it cannot delete source mirrors that\n");
|
|
printf(" were not yet scanned\n");
|
|
printf(" --address <ip> Bind the outgoing client socket to this source address\n");
|
|
printf(" -4, --ipv4 Force IPv4 for destination resolution\n");
|
|
printf(" -6, --ipv6 Force IPv6 for destination resolution\n");
|
|
printf(" --sockopts=OPTS Comma-separated OPT=VAL socket options applied before connect:\n");
|
|
printf(" TCP_NODELAY, SO_KEEPALIVE, SO_RCVBUF, SO_SNDBUF, SO_REUSEADDR\n");
|
|
printf(" -b, --backup Backup existing files before overwriting\n");
|
|
printf(" --backup-dir <dir> Directory for backups (requires --backup)\n");
|
|
printf(" --suffix <str> Backup suffix (default: ~)\n");
|
|
printf(" --stats Print transfer statistics at end\n");
|
|
printf(" -i, --itemize-changes Print an rsync-style per-file change line\n");
|
|
printf(" --out-format=FORMAT Output format (%%f %%n %%l %%b %%c %%C %%i %%M %%%%)\n");
|
|
printf(" --list-only List source files instead of transferring\n");
|
|
printf(" --log-file-format=FORMAT Per-file log line format (needs --log-file)\n");
|
|
printf(" -h, --human-readable Print byte sizes in human-readable form\n");
|
|
printf(" --max-depth <n> Maximum directory depth (0=unlimited)\n");
|
|
printf(" -x, --one-file-system Do not cross filesystem boundaries\n");
|
|
printf(" --log-file <path>, --log-file=<path> Write log messages to file\n");
|
|
printf(" --stderr=MODE Route logging to stderr: errors or all\n");
|
|
printf(" --partial Keep partial files on interrupted transfer\n");
|
|
printf(" --partial-dir <dir> Directory for partial files\n");
|
|
printf(" -T, --temp-dir <dir> Scratch dir for temp files before atomic install.\n");
|
|
printf(" Confined to the receive root: a relative dir resolves below\n");
|
|
printf(" it and an absolute/traversal dir is rejected. The dir must\n");
|
|
printf(" already exist; a different filesystem falls back to a\n");
|
|
printf(" non-atomic copy instead of aborting\n");
|
|
printf(" --fastsync-server-path <path>\n");
|
|
printf(" Path to fastsync-server on remote (default: fastsync-server)\n");
|
|
printf(" --old-args Accepted for rsync CLI compatibility; no effect (the\n");
|
|
printf(" remote server path is always safely quoted now)\n");
|
|
printf(" -M, --remote-option=OPT Append OPT to the REMOTE server invocation. SSH\n");
|
|
printf(" transport ONLY (user@host:path): a daemon (host::module) or\n");
|
|
printf(" local TCP destination rejects it (no remote command line to\n");
|
|
printf(" append to). Repeatable; each value is single-quote-escaped on\n");
|
|
printf(" the remote command line; empty values and values with control\n");
|
|
printf(" characters are rejected; -M OPT, -M=OPT and\n");
|
|
printf(" --remote-option=OPT work\n");
|
|
printf(" --trust-sender RECEIVER-LOCAL policy: trust the remote sender's file list\n");
|
|
printf(" and skip the receiver's own up-front path-traversal/\n");
|
|
printf(" containment re-validation of the incoming list (fewer checks,\n");
|
|
printf(" faster, potentially unsafe). It is never sent to the peer, so\n");
|
|
printf(" for a push it must be enabled on the receiving SERVER\n");
|
|
printf(" (fastsync-server --trust-sender) or forwarded with\n");
|
|
printf(" -M--trust-sender; the client flag alone has no effect\n");
|
|
printf(" -l, --links Copy symlinks as symlinks\n");
|
|
printf(" -L, --copy-links Transform symlinks into referent files\n");
|
|
printf(" --safe-links Skip symlinks whose target points outside the tree\n");
|
|
printf(" --copy-unsafe-links Copy unsafe symlinks (outside tree) as referent files\n");
|
|
printf(" -k, --copy-dirlinks Transform symlinks to directories into real dirs\n");
|
|
printf(" -K, --keep-dirlinks Keep an existing symlink-to-dir as that dir\n");
|
|
printf(" --munge-links Munge stored symlink targets (/rsyncd-munged/) on the receiver\n");
|
|
printf(" -H, --hard-links Preserve hard-link relationships across the transfer\n");
|
|
printf(" -S, --sparse Handle sparse files efficiently\n");
|
|
printf(
|
|
" -D Preserve device and special files (implies --devices --specials)\n");
|
|
printf(
|
|
" --devices Recreate device nodes on the destination (privileged; skipped when\n");
|
|
printf(" the receiver lacks CAP_MKNOD)\n");
|
|
printf(" --specials Recreate special files (FIFOs, sockets) on the destination\n");
|
|
printf(" --copy-devices Copy a source device's content as a regular file instead\n");
|
|
printf(" --write-devices Write received data into an existing destination device node\n");
|
|
printf(" --inplace Update files in-place (no temp+rename)\n");
|
|
printf(
|
|
" --preallocate Allocate destination file space up front (fail-fast on full disk)\n");
|
|
printf(" --append Resume a shorter destination by appending only its tail\n");
|
|
printf(" (prefix is not verified; requires --incremental)\n");
|
|
printf(" --append-verify Like --append, but verifies the retained prefix checksum\n");
|
|
printf(" before appending (falls back to a full transfer on mismatch)\n");
|
|
printf(" --fsync Fsync every written file before publication\n");
|
|
printf(" --compress-level <n> Compression level (default: 5)\n");
|
|
printf(" --zl <n> Alias for --compress-level\n");
|
|
printf(" --skip-compress=LIST Skip compression for suffixes in LIST (separated by\n");
|
|
printf(" '/' as in rsync, or ','); a leading dot is optional. The\n");
|
|
printf(" default is rsync 3.4.1's built-in skip-compress list\n");
|
|
printf(" --compress-threads <n> Compression worker threads (requires zstd threaded support)\n");
|
|
printf(" --no-OPTION Disable a supported boolean option\n");
|
|
printf(" --help Show this help\n");
|
|
printf(" -V, --version Show version\n");
|
|
}
|
|
|
|
void print_debug_usage(void) {
|
|
printf("Emitting debug flags: IO,PROTO,PACK,UTIL,ALL,NONE\n");
|
|
printf("Also accepted for rsync CLI parity (silent): ACL,BACKUP,BIND,CHDIR,\n");
|
|
printf("CONNECT,CMD,DEL,DELTASUM,DUP,EXIT,FILTER,FLIST,FUZZY,GENR,HASH,HLINK,\n");
|
|
printf("ICONV,NSTR,OWN,RECV,SEND,TIME.\n");
|
|
printf("Flags may be comma-separated, for example: --debug=io,proto\n");
|
|
printf("An optional level suffix is accepted (e.g. --debug=io2); level 0\n");
|
|
printf("silences that item. Unknown names are rejected.\n");
|
|
}
|
|
|
|
void print_info_usage(void) {
|
|
printf("Emitting info flags: COPY,NAME,MISC,SKIP,STATS,ALL,NONE\n");
|
|
printf("Also accepted for rsync CLI parity (silent): BACKUP,DEL,FLIST,MOUNT,\n");
|
|
printf("NONREG,PROGRESS,REMOVE,SYMSAFE.\n");
|
|
printf("Flags may be comma-separated, for example: --info=name,stats\n");
|
|
printf("An optional level suffix is accepted (e.g. --info=stats2); level 0\n");
|
|
printf("silences that item. Unknown names are rejected.\n");
|
|
}
|