rsync likely remains stuck in a busy-poll loop. A diagnosis report and patch proposal were created locally.
Published session
Prompt
## Plan Pass
You are planning a fixer patch before any edits happen.
Read the evidence bundle at `./evidence.json`. The prepared workspace is `./workspace` and it was acquired via `debian-source`. The original pre-edit snapshot is available at `./source` if you need to inspect it. For interpreter processes, plan from the script/application entrypoint evidence first and include the runtime only as a second investigation target unless the evidence proves a runtime bug.
Validation expectation: try the project-level build/test entrypoint from the workspace root before reporting only a focused leaf compile. Detected candidate(s): `./configure && make`. If the project-level command fails because dependencies or generated files are missing, include the exact command and failure reason in `## Validation`, then run the narrowest relevant compile/test that is still reproducible from a clean checkout.
Upstream-style expectation: before planning or editing, check for contribution/style docs (`CONTRIBUTING`, `HACKING`, `README-hacking`, `README.md`, `docs/`, `dev-docs/`) and scan the touched subsystem for local helpers. If the project has wrappers for file IO, path-relative IO, process spawning, memory allocation, logging, locking, or platform compatibility, prefer those wrappers over generic libc/std APIs. Do not invent a reproducer or user-visible failure that is not in the evidence bundle; if the evidence is profiler-only or indirect, describe it as a targeted mitigation or stop with a diagnosis instead of presenting a speculative patch as a confirmed bug fix. In the plan and final validation, name any such helper, convention, or evidence limit you found, or say that no relevant local helper was found. Treat this as a `rsync` upstream patch, not just a Debian-local workaround. Inspect the relevant code, nearby callers, project contribution docs, and local helper/compat APIs, but do not edit files in this pass.
Return a short markdown plan with these exact sections:
## Problem
## Evidence Confidence
## Proposed Subject
## Patch Plan
## Risks
## Validation
Classify `## Evidence Confidence` as exactly one of `reproduced`, `observed`, or `inferred`. Use `inferred` only for a no-patch diagnosis/report plan unless you can name the extra evidence you will collect before editing; inferred source patches are blocked by Fixer because they are not pull-request-ready. For `observed` source-patch plans, plan to say in the final `## Issue Connection` that the failure was observed by Fixer and not independently reproduced. The plan must explain how the proposed code change addresses the observed issue evidence, call out any prior Fixer patch that should be improved or replaced, reject awkward control flow such as avoidable `goto` if there is a cleaner bounded alternative, name any local helper APIs or maintainer conventions the patch should follow, and keep the intended maintainer-facing explanation clear enough that someone unfamiliar with the local complaint wording can still follow the fix. In `## Validation`, name the reproducible configure/build/test entrypoint you will try from the workspace root before any focused leaf compile or smoke check, and include one bounded independent reproduction attempt for the collected failure signal when it is safe and cheap. Do not plan to claim `reproduced` unless that reproduction command or test can actually show the failure.
## Patch Pass
You are working on a bounded fixer proposal.
Read the evidence bundle at `./evidence.json`. The prepared workspace is `./workspace` and it was acquired via `debian-source`. Produce the smallest reasonable patch for the target repository, keep the change upstreamable, prefer the clearest control flow available, and do not keep avoidable `goto` when a simpler structure would read better. Before introducing new file, process, allocation, locking, networking, or platform APIs, inspect nearby code and project contribution docs for existing helpers or compatibility wrappers and use those local patterns unless you can explain why they do not fit. Validate from a reproducible workspace-root entrypoint before falling back to focused leaf commands; if a build or test cannot run, report the exact command, the exact blocker, and any narrower check you ran instead. During validation, also try one bounded independent reproduction of the collected failure signal when it is safe and cheap, such as a failing test, smoke command, perf/strace comparison, or before/after runtime check. Only use `reproduced` if that command or test actually reproduced the failure; otherwise keep `observed` and report the reproduction blocker. The final explanation must connect the observed issue evidence to the actual code change, not just paraphrase the diff. Write like a maintainer is going to read the patch mail cold: explain the bug in plain language, define subsystem-specific jargon the first time you need it, and make the causal story obvious. Explicitly classify evidence confidence as `reproduced`, `observed`, or `inferred`: `reproduced` means you reproduced the failure locally; `observed` means Fixer has direct crash/log/trace evidence but you did not independently reproduce it; `inferred` means the source patch is not pull-request-ready, so do not leave a source diff unless you first gather stronger observed/reproduced evidence; otherwise return a no-patch diagnosis/report. For any source-changing `observed` patch, say explicitly in `## Issue Connection` that the failure was observed by Fixer and not independently reproduced. If you introduce non-obvious state translation, index remapping, or backend split logic, add a short source comment that explains the invariant being preserved.
Start by explaining the likely root cause from the collected perf, strace, and /proc evidence. If you cannot land a safe patch, leave a diagnosis that is strong enough for an upstream bug report.
Validation expectation: try the project-level build/test entrypoint from the workspace root before reporting only a focused leaf compile. Detected candidate(s): `./configure && make`. If the project-level command fails because dependencies or generated files are missing, include the exact command and failure reason in `## Validation`, then run the narrowest relevant compile/test that is still reproducible from a clean checkout.
Upstream-style expectation: before planning or editing, check for contribution/style docs (`CONTRIBUTING`, `HACKING`, `README-hacking`, `README.md`, `docs/`, `dev-docs/`) and scan the touched subsystem for local helpers. If the project has wrappers for file IO, path-relative IO, process spawning, memory allocation, logging, locking, or platform compatibility, prefer those wrappers over generic libc/std APIs. Do not invent a reproducer or user-visible failure that is not in the evidence bundle; if the evidence is profiler-only or indirect, describe it as a targeted mitigation or stop with a diagnosis instead of presenting a speculative patch as a confirmed bug fix. In the plan and final validation, name any such helper, convention, or evidence limit you found, or say that no relevant local helper was found. Treat this as a `rsync` upstream patch, not just a Debian-local workaround.
Keep the change narrowly scoped and summarize validation clearly.
In every authoring pass, your final response must start with `Subject: <single-line git commit subject>` and then include these markdown sections exactly:
## Commit Message
A short upstream-friendly explanation of what changed and why. Write it in plain language that a maintainer can follow without local complaint context. If you use subsystem jargon, define it immediately.
## Evidence Confidence
Exactly one word: `reproduced`, `observed`, or `inferred`. Use `reproduced` only when you reproduced the failure locally with a command or test, and include that command/test in `## Validation`. Use `observed` when Fixer has direct crash/log/trace evidence but you did not independently reproduce it. If `## Git Add Paths` lists source files for an `observed` patch, `## Issue Connection` must explicitly say the failure was observed by Fixer and not independently reproduced. Use `inferred` for profiler/strace/indirect evidence; inferred responses may be no-patch diagnoses or reports, but inferred source patches are not pull-request-ready until stronger evidence is gathered.
## Issue Connection
Write this as maintainer-facing patch mail, not as local Fixer notes. Cover four things explicitly in readable sentences: the user-visible symptom or the exact collected signal, the code-level cause or the cautious inference from evidence, the specific change you made, and the expected effect. Do not invent a reproducer, command line, crash, or user-visible failure that is not present in the evidence bundle. If the evidence is direct-but-not-reproduced, say it was observed by Fixer and not independently reproduced. If the evidence is indirect and you did not gather stronger evidence, do not leave a source diff; write a no-patch diagnosis/report instead. Include an explicit effect sentence such as `The expected effect is ...`, `This should reduce ...`, or `This prevents ...` for source patches. If the logic is non-obvious in code, mention that you added a short explanatory comment.
## Git Add Paths
List the repo-relative paths that belong in the final patch, one per line. Use `None` only when you intentionally made no source changes. Include intentionally new files, and do not list generated build artifacts.
## Validation
List the checks you ran, or say clearly that you could not run them. Include the independent reproduction command/test and result when `## Evidence Confidence` is `reproduced`; if reproduction was attempted but blocked, name the exact blocker and keep confidence at `observed` or `inferred`.
Before editing, read the plan at `./plan-output.txt` and follow it unless the code proves part of it wrong. If you change course, say so explicitly in the final write-up instead of silently drifting from the plan.
## Review Pass 1
You are reviewing a freshly generated fixer patch.
Read the evidence bundle at `./evidence.json`. The prepared workspace is `./workspace` and it was acquired via `debian-source`. Review the first patch pass. The original pre-edit snapshot is available at `./source` for diffing.
Upstream-style expectation: before planning or editing, check for contribution/style docs (`CONTRIBUTING`, `HACKING`, `README-hacking`, `README.md`, `docs/`, `dev-docs/`) and scan the touched subsystem for local helpers. If the project has wrappers for file IO, path-relative IO, process spawning, memory allocation, logging, locking, or platform compatibility, prefer those wrappers over generic libc/std APIs. Do not invent a reproducer or user-visible failure that is not in the evidence bundle; if the evidence is profiler-only or indirect, describe it as a targeted mitigation or stop with a diagnosis instead of presenting a speculative patch as a confirmed bug fix. In the plan and final validation, name any such helper, convention, or evidence limit you found, or say that no relevant local helper was found. Treat this as a `rsync` upstream patch, not just a Debian-local workaround.
Validation expectation: try the project-level build/test entrypoint from the workspace root before reporting only a focused leaf compile. Detected candidate(s): `./configure && make`, `make` and, if available, `make check`. If the project-level command fails because dependencies or generated files are missing, include the exact command and failure reason in `## Validation`, then run the narrowest relevant compile/test that is still reproducible from a clean checkout. The latest author response is at `./patch-output.txt`. Inspect the current code and changed paths like a strict code reviewer. Focus on correctness, regressions, maintainability, awkward control flow such as avoidable `goto`, missing validation, weak or non-gittable commit message text, and explanations that fail to connect the observed issue evidence to the code change. Also review the maintainer experience: the patch mail should be easy to accept upstream, the user-visible bug should be explained in plain language, subsystem-specific jargon should be defined when first used, and any non-obvious state translation or index remapping in code should have a short explanatory comment. Reject patches that omit `## Evidence Confidence`, use anything other than `reproduced`, `observed`, or `inferred`, or sound more certain than that evidence level allows. Reject patches that claim `reproduced` unless `## Validation` names the concrete reproduction command or test and its result. Reject patches that invent a reproducer, command line, crash, or user-visible failure not present in the evidence bundle; indirect profiler or strace evidence may justify a cautious mitigation, but the author must say it is indirect instead of presenting it as a confirmed upstream bug. Reject patches that introduce generic libc/std APIs when nearby code or project docs provide a local compat/helper API for the same job, unless the author explicitly justifies the exception. Reject validation that only reports a leaf object/syntax build when a project-level configure/build/test entrypoint exists and was not attempted; if a full build cannot run, the author must show the exact failed command and blocker.
Do not apply code changes in this pass.
Return a short markdown review report. The first non-empty line must be exactly one of:
RESULT: ok
RESULT: fix-needed
If you choose `RESULT: fix-needed`, add a `## Findings` section with concrete, actionable items.
Response
## Plan Pass
## Problem
Fixer observed `/usr/bin/rsync --server --sender ...` with about 19% sampled CPU and kernel path-lookup symbols, but the captured live state shows rsync sleeping in `pselect6()` with a ~55s timeout and only one syscall line over 5 seconds. That is not enough to identify a confirmed rsync busy-loop bug.
## Evidence Confidence
inferred
## Proposed Subject
No source patch yet: collect sender-side evidence before editing.
## Patch Plan
Do not patch `rsync` from the current bundle. The observed command is a sender process, while the existing Debian patch `debian/patches/syscall_use_openat2_RESOLVE_BENEATH_on_Linux_for_secure_relative_open.patch` targets receiver-side `secure_relative_open()` basis-file handling, so it should not be improved or replaced for this evidence.
If new evidence confirms a real sender-side loop, investigate `io.c:perform_io()`, `sender.c:receive_sums()`, and `main.c:do_server_sender()` first. Follow rsync conventions found locally: use `rprintf()`/`rsyserr()` for diagnostics, rsync allocation helpers such as `new_array()`/`out_of_memory()`, existing fd wrappers such as `set_nonblocking()`/`set_blocking()`, and avoid avoidable `goto` in any new bounded control flow.
## Risks
A speculative patch could regress rsync’s multiplexed I/O or timeout/keepalive behavior. The current evidence also fits normal waiting after filesystem traversal, because `__d_lookup_rcu` is consistent with path scanning and the sampled process was sleeping in `pselect6()`.
## Validation
Before any focused check, run the project entrypoint from the workspace root:
`./configure && make`
Then run `make check` if the build succeeds, per `testsuite/README.testsuite`.
Bounded independent evidence attempt: build the unmodified tree, run a local sender-style transfer over `support/lsh.sh` on a synthetic directory with many files, and capture `strace -tt -T -f` plus a short CPU sample. Only claim reproduction if that command shows repeated short-timeout `select`/`pselect6` wakeups with sustained CPU, not merely one blocking `pselect6()` call.
## Patch Pass
Subject: no patch: diagnose rsync sender pselect sample
## Commit Message
No source change. The collected evidence does not establish an rsync busy-loop bug: the sampled sender was sleeping in `pselect6()` with a long timeout, while the kernel path-lookup samples are consistent with prior directory traversal work.
This follows the saved plan in `plan-output.txt`: do not patch until stronger sender-side evidence exists.
## Evidence Confidence
inferred
## Issue Connection
The likely root cause from the collected perf, strace, and `/proc` evidence is not a confirmed rsync event-loop defect. Fixer saw `/usr/bin/rsync --server --sender ...` with a 19.2% sampled CPU maximum and `__d_lookup_rcu` as the hottest kernel symbol, but `/proc` reported state `S (sleeping)`, `wchan` was `poll_schedule_timeout.constprop.0`, and the 5-second strace captured only one `pselect6()` call with about 54 seconds left in its timeout.
That signal is indirect: it may describe normal sender-side filesystem traversal followed by idle waiting, not repeated short poll wakeups. I inspected the relevant sender and I/O paths (`main.c:do_server_sender()`, `sender.c:receive_sums()`, `io.c:perform_io()`) and did not find a safe code-level cause to patch from this evidence. I also checked project docs (`README.md`, `INSTALL.md`, `testsuite/README.testsuite`) and local conventions: rsync uses `rprintf()`/`rsyserr()` for diagnostics, allocation wrappers such as `new_array()`, fd helpers such as `set_nonblocking()`, and its existing multiplexed I/O loop in `io.c`.
No change was made. The expected effect is to avoid an upstream patch that would be speculative and potentially risky for rsync’s multiplexed I/O behavior.
## Git Add Paths
None
## Validation
`./configure && make` from the workspace root did not complete. Exact blocker: `config.status: error: cannot find input file: 'zlib/dummy.in'`.
`./configure --with-included-zlib=no && make` also did not complete. Exact blocker: `config.status: error: cannot find input file: 'zlib/dummy.in'`.
Following Debian’s own `debian/rules` setup, I tried `mkdir -p zlib popt && touch zlib/dummy.in popt/dummy.in && ./configure --with-included-zlib=no --disable-md5-asm --with-rrsync`, then `make`. Configure succeeded, but `make` failed because the environment lacks the Debian build dependency for system popt and the `+ds1` source has no bundled popt headers: `main.c:30:10: fatal error: popt.h: No such file or directory`.
Independent reproduction attempt: `strace -f -tt -T -e trace=select,pselect6,poll,ppoll ... /usr/bin/rsync -a -e "$PWD/support/lsh.sh --no-cd" "lh:$tmp/src/" "$tmp/dst/"` was blocked by ptrace restrictions: `PTRACE_TRACEME: Operation not permitted` and `ptrace(PTRACE_SEIZE, 7): Operation not permitted`.
A bounded untraced sender-style smoke transfer using installed rsync completed normally: `timeout 10 /usr/bin/rsync -a -e "$PWD/support/lsh.sh --no-cd" "lh:$tmp/src/" "$tmp/dst/"` exited `0`, copied 2000 files, and took `elapsed=0.04 user=0.00 sys=0.01`. This did not reproduce the collected failure signal.
## Review Pass 1
RESULT: ok
The first pass is acceptable as a no-patch diagnosis. It correctly classifies the evidence as `inferred`, does not leave a source diff, and does not overstate the profiler/strace data as a reproduced rsync bug.
I verified the current patch state: `git diff` is empty and `git status --short` reports no tracked changes. The extra files seen only by a raw directory compare are generated/ignored build artifacts from validation, not proposed patch content.
The author output also meets the review constraints: it cites the exact collected signal, explains why the `pselect6()` sample is insufficient for a source patch, names the relevant rsync sender/I/O paths and local conventions (`rprintf()`/`rsyserr()`, allocation wrappers, fd helpers), and reports project-level validation attempts with exact blockers.
Diff
--- a/daemon-parm.h 1970-01-01 04:00:00.000000000 +0400
+++ b/daemon-parm.h 2026-05-11 10:27:12.805048148 +0400
@@ -0,0 +1,381 @@
+/* DO NOT EDIT THIS FILE! It is auto-generated from a list of values in ./daemon-parm.txt! */
+
+typedef struct {
+/********** STRING **********/
+ char* bind_address;
+ char* daemon_chroot;
+ char* daemon_gid;
+ char* daemon_uid;
+ char* motd_file;
+ char* pid_file;
+ char* socket_options;
+
+/********** INTEGER **********/
+ int listen_backlog;
+ int rsync_port;
+
+/********** BOOL **********/
+ BOOL proxy_protocol;
+
+/********** EXP **********/
+ BOOL bind_address_EXP;
+ BOOL daemon_chroot_EXP;
+ BOOL daemon_gid_EXP;
+ BOOL daemon_uid_EXP;
+ BOOL motd_file_EXP;
+ BOOL pid_file_EXP;
+ BOOL socket_options_EXP;
+} global_vars;
+
+typedef struct {
+/********** STRING **********/
+ char* auth_users;
+ char* charset;
+ char* comment;
+ char* dont_compress;
+ char* early_exec;
+ char* exclude;
+ char* exclude_from;
+ char* filter;
+ char* gid;
+ char* hosts_allow;
+ char* hosts_deny;
+ char* include;
+ char* include_from;
+ char* incoming_chmod;
+ char* lock_file;
+ char* log_file;
+ char* log_format;
+ char* name;
+ char* name_converter;
+ char* outgoing_chmod;
+ char* postxfer_exec;
+ char* prexfer_exec;
+ char* refuse_options;
+ char* secrets_file;
+ char* syslog_tag;
+ char* uid;
+
+/********** PATH **********/
+ char* path;
+ char* temp_dir;
+
+/********** INTEGER **********/
+ int max_connections;
+ int max_verbosity;
+ int timeout;
+
+/********** ENUM **********/
+ int syslog_facility;
+
+/********** BOOL **********/
+ BOOL fake_super;
+ BOOL forward_lookup;
+ BOOL ignore_errors;
+ BOOL ignore_nonreadable;
+ BOOL list;
+ BOOL read_only;
+ BOOL reverse_lookup;
+ BOOL strict_modes;
+ BOOL transfer_logging;
+ BOOL write_only;
+
+/********** BOOL3 **********/
+ BOOL munge_symlinks;
+ BOOL numeric_ids;
+ BOOL open_noatime;
+ BOOL use_chroot;
+
+/********** EXP **********/
+ BOOL auth_users_EXP;
+ BOOL charset_EXP;
+ BOOL comment_EXP;
+ BOOL dont_compress_EXP;
+ BOOL early_exec_EXP;
+ BOOL exclude_EXP;
+ BOOL exclude_from_EXP;
+ BOOL filter_EXP;
+ BOOL gid_EXP;
+ BOOL hosts_allow_EXP;
+ BOOL hosts_deny_EXP;
+ BOOL include_EXP;
+ BOOL include_from_EXP;
+ BOOL incoming_chmod_EXP;
+ BOOL lock_file_EXP;
+ BOOL log_file_EXP;
+ BOOL log_format_EXP;
+ BOOL name_EXP;
+ BOOL name_converter_EXP;
+ BOOL outgoing_chmod_EXP;
+ BOOL postxfer_exec_EXP;
+ BOOL prexfer_exec_EXP;
+ BOOL refuse_options_EXP;
+ BOOL secrets_file_EXP;
+ BOOL syslog_tag_EXP;
+ BOOL uid_EXP;
+ BOOL path_EXP;
+ BOOL temp_dir_EXP;
+} local_vars;
+
+typedef struct {
+ global_vars g;
+ local_vars l;
+} all_vars;
+
+static const all_vars Defaults = {
+ { /* Globals: */
+
+/********** STRING **********/
+ NULL, /* bind_address */
+ NULL, /* daemon_chroot */
+ NULL, /* daemon_gid */
+ NULL, /* daemon_uid */
+ NULL, /* motd_file */
+ NULL, /* pid_file */
+ NULL, /* socket_options */
+
+/********** INTEGER **********/
+ 5, /* listen_backlog */
+ 0, /* rsync_port */
+
+/********** BOOL **********/
+ False, /* proxy_protocol */
+
+/********** EXP **********/
+ False, /* bind_address_EXP */
+ False, /* daemon_chroot_EXP */
+ False, /* daemon_gid_EXP */
+ False, /* daemon_uid_EXP */
+ False, /* motd_file_EXP */
+ False, /* pid_file_EXP */
+ False, /* socket_options_EXP */
+
+ }, { /* Locals: */
+
+/********** STRING **********/
+ NULL, /* auth_users */
+ NULL, /* charset */
+ NULL, /* comment */
+ DEFAULT_DONT_COMPRESS, /* dont_compress */
+ NULL, /* early_exec */
+ NULL, /* exclude */
+ NULL, /* exclude_from */
+ NULL, /* filter */
+ NULL, /* gid */
+ NULL, /* hosts_allow */
+ NULL, /* hosts_deny */
+ NULL, /* include */
+ NULL, /* include_from */
+ NULL, /* incoming_chmod */
+ DEFAULT_LOCK_FILE, /* lock_file */
+ NULL, /* log_file */
+ "%o %h [%a] %m (%u) %f %l", /* log_format */
+ NULL, /* name */
+ NULL, /* name_converter */
+ NULL, /* outgoing_chmod */
+ NULL, /* postxfer_exec */
+ NULL, /* prexfer_exec */
+ NULL, /* refuse_options */
+ NULL, /* secrets_file */
+ "rsyncd", /* syslog_tag */
+ NULL, /* uid */
+
+/********** PATH **********/
+ NULL, /* path */
+ NULL, /* temp_dir */
+
+/********** INTEGER **********/
+ 0, /* max_connections */
+ 1, /* max_verbosity */
+ 0, /* timeout */
+
+/********** ENUM **********/
+ LOG_DAEMON, /* syslog_facility */
+
+/********** BOOL **********/
+ False, /* fake_super */
+ True, /* forward_lookup */
+ False, /* ignore_errors */
+ False, /* ignore_nonreadable */
+ True, /* list */
+ True, /* read_only */
+ True, /* reverse_lookup */
+ True, /* strict_modes */
+ False, /* transfer_logging */
+ False, /* write_only */
+
+/********** BOOL3 **********/
+ Unset, /* munge_symlinks */
+ Unset, /* numeric_ids */
+ Unset, /* open_noatime */
+ Unset, /* use_chroot */
+
+/********** EXP **********/
+ False, /* auth_users_EXP */
+ False, /* charset_EXP */
+ False, /* comment_EXP */
+ False, /* dont_compress_EXP */
+ False, /* early_exec_EXP */
+ False, /* exclude_EXP */
+ False, /* exclude_from_EXP */
+ False, /* filter_EXP */
+ False, /* gid_EXP */
+ False, /* hosts_allow_EXP */
+ False, /* hosts_deny_EXP */
+ False, /* include_EXP */
+ False, /* include_from_EXP */
+ False, /* incoming_chmod_EXP */
+ False, /* lock_file_EXP */
+ False, /* log_file_EXP */
+ False, /* log_format_EXP */
+ False, /* name_EXP */
+ False, /* name_converter_EXP */
+ False, /* outgoing_chmod_EXP */
+ False, /* postxfer_exec_EXP */
+ False, /* prexfer_exec_EXP */
+ False, /* refuse_options_EXP */
+ False, /* secrets_file_EXP */
+ False, /* syslog_tag_EXP */
+ False, /* uid_EXP */
+ False, /* path_EXP */
+ False, /* temp_dir_EXP */
+
+ }
+};
+
+static all_vars Vars;
+
+static const struct parm_struct parm_table[] = {
+ {"address", P_STRING, P_GLOBAL, &Vars.g.bind_address, NULL, 0},
+ {"daemon chroot", P_STRING, P_GLOBAL, &Vars.g.daemon_chroot, NULL, 0},
+ {"daemon gid", P_STRING, P_GLOBAL, &Vars.g.daemon_gid, NULL, 0},
+ {"daemon uid", P_STRING, P_GLOBAL, &Vars.g.daemon_uid, NULL, 0},
+ {"motd file", P_STRING, P_GLOBAL, &Vars.g.motd_file, NULL, 0},
+ {"pid file", P_STRING, P_GLOBAL, &Vars.g.pid_file, NULL, 0},
+ {"socket options", P_STRING, P_GLOBAL, &Vars.g.socket_options, NULL, 0},
+
+ {"listen backlog", P_INTEGER, P_GLOBAL, &Vars.g.listen_backlog, NULL, 0},
+ {"port", P_INTEGER, P_GLOBAL, &Vars.g.rsync_port, NULL, 0},
+
+ {"proxy protocol", P_BOOL, P_GLOBAL, &Vars.g.proxy_protocol, NULL, 0},
+
+ {"auth users", P_STRING, P_LOCAL, &Vars.l.auth_users, NULL, 0},
+ {"charset", P_STRING, P_LOCAL, &Vars.l.charset, NULL, 0},
+ {"comment", P_STRING, P_LOCAL, &Vars.l.comment, NULL, 0},
+ {"dont compress", P_STRING, P_LOCAL, &Vars.l.dont_compress, NULL, 0},
+ {"early exec", P_STRING, P_LOCAL, &Vars.l.early_exec, NULL, 0},
+ {"exclude", P_STRING, P_LOCAL, &Vars.l.exclude, NULL, 0},
+ {"exclude from", P_STRING, P_LOCAL, &Vars.l.exclude_from, NULL, 0},
+ {"filter", P_STRING, P_LOCAL, &Vars.l.filter, NULL, 0},
+ {"gid", P_STRING, P_LOCAL, &Vars.l.gid, NULL, 0},
+ {"hosts allow", P_STRING, P_LOCAL, &Vars.l.hosts_allow, NULL, 0},
+ {"hosts deny", P_STRING, P_LOCAL, &Vars.l.hosts_deny, NULL, 0},
+ {"include", P_STRING, P_LOCAL, &Vars.l.include, NULL, 0},
+ {"include from", P_STRING, P_LOCAL, &Vars.l.include_from, NULL, 0},
+ {"incoming chmod", P_STRING, P_LOCAL, &Vars.l.incoming_chmod, NULL, 0},
+ {"lock file", P_STRING, P_LOCAL, &Vars.l.lock_file, NULL, 0},
+ {"log file", P_STRING, P_LOCAL, &Vars.l.log_file, NULL, 0},
+ {"log format", P_STRING, P_LOCAL, &Vars.l.log_format, NULL, 0},
+ {"name", P_STRING, P_LOCAL, &Vars.l.name, NULL, 0},
+ {"name converter", P_STRING, P_LOCAL, &Vars.l.name_converter, NULL, 0},
+ {"outgoing chmod", P_STRING, P_LOCAL, &Vars.l.outgoing_chmod, NULL, 0},
+ {"post-xfer exec", P_STRING, P_LOCAL, &Vars.l.postxfer_exec, NULL, 0},
+ {"pre-xfer exec", P_STRING, P_LOCAL, &Vars.l.prexfer_exec, NULL, 0},
+ {"refuse options", P_STRING, P_LOCAL, &Vars.l.refuse_options, NULL, 0},
+ {"secrets file", P_STRING, P_LOCAL, &Vars.l.secrets_file, NULL, 0},
+ {"syslog tag", P_STRING, P_LOCAL, &Vars.l.syslog_tag, NULL, 0},
+ {"uid", P_STRING, P_LOCAL, &Vars.l.uid, NULL, 0},
+
+ {"path", P_PATH, P_LOCAL, &Vars.l.path, NULL, 0},
+ {"temp dir", P_PATH, P_LOCAL, &Vars.l.temp_dir, NULL, 0},
+
+ {"max connections", P_INTEGER, P_LOCAL, &Vars.l.max_connections, NULL, 0},
+ {"max verbosity", P_INTEGER, P_LOCAL, &Vars.l.max_verbosity, NULL, 0},
+ {"timeout", P_INTEGER, P_LOCAL, &Vars.l.timeout, NULL, 0},
+
+ {"syslog facility", P_ENUM, P_LOCAL, &Vars.l.syslog_facility, enum_syslog_facility, 0},
+
+ {"fake super", P_BOOL, P_LOCAL, &Vars.l.fake_super, NULL, 0},
+ {"forward lookup", P_BOOL, P_LOCAL, &Vars.l.forward_lookup, NULL, 0},
+ {"ignore errors", P_BOOL, P_LOCAL, &Vars.l.ignore_errors, NULL, 0},
+ {"ignore nonreadable", P_BOOL, P_LOCAL, &Vars.l.ignore_nonreadable, NULL, 0},
+ {"list", P_BOOL, P_LOCAL, &Vars.l.list, NULL, 0},
+ {"read only", P_BOOL, P_LOCAL, &Vars.l.read_only, NULL, 0},
+ {"reverse lookup", P_BOOL, P_LOCAL, &Vars.l.reverse_lookup, NULL, 0},
+ {"strict modes", P_BOOL, P_LOCAL, &Vars.l.strict_modes, NULL, 0},
+ {"transfer logging", P_BOOL, P_LOCAL, &Vars.l.transfer_logging, NULL, 0},
+ {"write only", P_BOOL, P_LOCAL, &Vars.l.write_only, NULL, 0},
+
+ {"munge symlinks", P_BOOL3, P_LOCAL, &Vars.l.munge_symlinks, NULL, 0},
+ {"numeric ids", P_BOOL3, P_LOCAL, &Vars.l.numeric_ids, NULL, 0},
+ {"open noatime", P_BOOL3, P_LOCAL, &Vars.l.open_noatime, NULL, 0},
+ {"use chroot", P_BOOL3, P_LOCAL, &Vars.l.use_chroot, NULL, 0},
+
+ {NULL, P_BOOL, P_NONE, NULL, NULL, 0}
+};
+
+FN_GLOBAL_STRING(lp_bind_address, bind_address)
+FN_GLOBAL_STRING(lp_daemon_chroot, daemon_chroot)
+FN_GLOBAL_STRING(lp_daemon_gid, daemon_gid)
+FN_GLOBAL_STRING(lp_daemon_uid, daemon_uid)
+FN_GLOBAL_STRING(lp_motd_file, motd_file)
+FN_GLOBAL_STRING(lp_pid_file, pid_file)
+FN_GLOBAL_STRING(lp_socket_options, socket_options)
+
+FN_GLOBAL_INTEGER(lp_listen_backlog, listen_backlog)
+FN_GLOBAL_INTEGER(lp_rsync_port, rsync_port)
+
+FN_GLOBAL_BOOL(lp_proxy_protocol, proxy_protocol)
+
+FN_LOCAL_STRING(lp_auth_users, auth_users)
+FN_LOCAL_STRING(lp_charset, charset)
+FN_LOCAL_STRING(lp_comment, comment)
+FN_LOCAL_STRING(lp_dont_compress, dont_compress)
+FN_LOCAL_STRING(lp_early_exec, early_exec)
+FN_LOCAL_STRING(lp_exclude, exclude)
+FN_LOCAL_STRING(lp_exclude_from, exclude_from)
+FN_LOCAL_STRING(lp_filter, filter)
+FN_LOCAL_STRING(lp_gid, gid)
+FN_LOCAL_STRING(lp_hosts_allow, hosts_allow)
+FN_LOCAL_STRING(lp_hosts_deny, hosts_deny)
+FN_LOCAL_STRING(lp_include, include)
+FN_LOCAL_STRING(lp_include_from, include_from)
+FN_LOCAL_STRING(lp_incoming_chmod, incoming_chmod)
+FN_LOCAL_STRING(lp_lock_file, lock_file)
+FN_LOCAL_STRING(lp_log_file, log_file)
+FN_LOCAL_STRING(lp_log_format, log_format)
+FN_LOCAL_STRING(lp_name, name)
+FN_LOCAL_STRING(lp_name_converter, name_converter)
+FN_LOCAL_STRING(lp_outgoing_chmod, outgoing_chmod)
+FN_LOCAL_STRING(lp_postxfer_exec, postxfer_exec)
+FN_LOCAL_STRING(lp_prexfer_exec, prexfer_exec)
+FN_LOCAL_STRING(lp_refuse_options, refuse_options)
+FN_LOCAL_STRING(lp_secrets_file, secrets_file)
+FN_LOCAL_STRING(lp_syslog_tag, syslog_tag)
+FN_LOCAL_STRING(lp_uid, uid)
+
+FN_LOCAL_STRING(lp_path, path)
+FN_LOCAL_STRING(lp_temp_dir, temp_dir)
+
+FN_LOCAL_INTEGER(lp_max_connections, max_connections)
+FN_LOCAL_INTEGER(lp_max_verbosity, max_verbosity)
+FN_LOCAL_INTEGER(lp_timeout, timeout)
+
+FN_LOCAL_INTEGER(lp_syslog_facility, syslog_facility)
+
+FN_LOCAL_BOOL(lp_fake_super, fake_super)
+FN_LOCAL_BOOL(lp_forward_lookup, forward_lookup)
+FN_LOCAL_BOOL(lp_ignore_errors, ignore_errors)
+FN_LOCAL_BOOL(lp_ignore_nonreadable, ignore_nonreadable)
+FN_LOCAL_BOOL(lp_list, list)
+FN_LOCAL_BOOL(lp_read_only, read_only)
+FN_LOCAL_BOOL(lp_reverse_lookup, reverse_lookup)
+FN_LOCAL_BOOL(lp_strict_modes, strict_modes)
+FN_LOCAL_BOOL(lp_transfer_logging, transfer_logging)
+FN_LOCAL_BOOL(lp_write_only, write_only)
+
+FN_LOCAL_BOOL(lp_munge_symlinks, munge_symlinks)
+FN_LOCAL_BOOL(lp_numeric_ids, numeric_ids)
+FN_LOCAL_BOOL(lp_open_noatime, open_noatime)
+FN_LOCAL_BOOL(lp_use_chroot, use_chroot)
+
--- a/lib/dummy 1970-01-01 04:00:00.000000000 +0400
+++ b/lib/dummy 2026-05-11 10:27:03.776931993 +0400
@@ -0,0 +1,2 @@
+This is a dummy file to ensure that the lib directory gets created
+by configure when a VPATH is used.
--- a/proto.h 1970-01-01 04:00:00.000000000 +0400
+++ b/proto.h 2026-05-11 10:27:12.862333155 +0400
@@ -0,0 +1,464 @@
+/* This file is automatically generated with "make proto". DO NOT EDIT */
+
+int allow_access(const char *addr, const char **host_ptr, int i);
+void free_acl(stat_x *sxp);
+int get_acl(const char *fname, stat_x *sxp);
+void send_acl(int f, stat_x *sxp);
+void receive_acl(int f, struct file_struct *file);
+void cache_tmp_acl(struct file_struct *file, stat_x *sxp);
+void uncache_tmp_acls(void);
+int set_acl(const char *fname, const struct file_struct *file, stat_x *sxp, mode_t new_mode);
+void match_acl_ids(void);
+int default_perms_for_dir(const char *dir);
+void base64_encode(const char *buf, int len, char *out, int pad);
+char *auth_server(int f_in, int f_out, int module, const char *host,
+ const char *addr, const char *leader);
+void auth_client(int fd, const char *user, const char *challenge);
+char *get_backup_name(const char *fname);
+int make_backup(const char *fname, BOOL prefer_rename);
+void write_stream_flags(int fd);
+void read_stream_flags(int fd);
+void check_batch_flags(void);
+void open_batch_files(void);
+void write_batch_shell_file(void);
+struct name_num_item *parse_csum_name(const char *name, int len);
+void parse_checksum_choice(int final_call);
+int csum_len_for_type(int cst, BOOL flist_csum);
+int canonical_checksum(int csum_type);
+uint32 get_checksum1(char *buf1, int32 len);
+void get_checksum2(char *buf, int32 len, char *sum);
+void file_checksum(const char *fname, const STRUCT_STAT *st_p, char *sum);
+int sum_init(struct name_num_item *nni, int seed);
+void sum_update(const char *p, int32 len);
+void sum_end(char *sum);
+void init_checksum_choices();
+struct chmod_mode_struct *parse_chmod(const char *modestr,
+ struct chmod_mode_struct **root_mode_ptr);
+int tweak_mode(int mode, struct chmod_mode_struct *chmod_modes);
+int free_chmod_mode(struct chmod_mode_struct *chmod_modes);
+void close_all(void);
+NORETURN void _exit_cleanup(int code, const char *file, int line);
+void cleanup_disable(void);
+void cleanup_set(const char *fnametmp, const char *fname, struct file_struct *file,
+ int fd_r, int fd_w);
+void cleanup_set_pid(pid_t pid);
+char *client_addr(int fd);
+char *client_name(const char *ipaddr);
+int read_proxy_protocol_header(int fd);
+int start_socket_client(char *host, int remote_argc, char *remote_argv[],
+ int argc, char *argv[]);
+int start_inband_exchange(int f_in, int f_out, const char *user, int argc, char *argv[]);
+void set_env_str(const char *var, const char *str);
+void set_env_num(const char *var, long num);
+BOOL namecvt_call(const char *cmd, const char **name_p, id_t *id_p);
+int start_daemon(int f_in, int f_out);
+int daemon_main(void);
+void set_allow_inc_recurse(void);
+void parse_compress_choice(int final_call);
+struct name_num_item *get_nni_by_name(struct name_num_obj *nno, const char *name, int len);
+struct name_num_item *get_nni_by_num(struct name_num_obj *nno, int num);
+void validate_choice_vs_env(int ntype, int num1, int num2);
+int get_default_nno_list(struct name_num_obj *nno, char *to_buf, int to_buf_len, char dup_markup);
+void setup_protocol(int f_out,int f_in);
+void output_daemon_greeting(int f_out, int am_client);
+void negotiate_daemon_auth(int f_out, int am_client);
+int get_subprotocol_version();
+int claim_connection(char *fname, int max_connections);
+enum delret delete_item(char *fbuf, uint16 mode, uint16 flags);
+uint16 get_del_for_flag(uint16 mode);
+void implied_include_partial_string(const char *s_start, const char *s_end);
+void free_implied_include_partial_string();
+void add_implied_include(const char *arg, int skip_daemon_module);
+void set_filter_dir(const char *dir, unsigned int dirlen);
+void *push_local_filters(const char *dir, unsigned int dirlen);
+void pop_local_filters(void *mem);
+void change_local_filter_dir(const char *dname, int dlen, int dir_depth);
+int name_is_excluded(const char *fname, int name_flags, int filter_level);
+int check_server_filter(filter_rule_list *listp, enum logcode code, const char *name, int name_flags);
+int check_filter(filter_rule_list *listp, enum logcode code,
+ const char *name, int name_flags);
+const filter_rule *rule_template(uint32 rflags);
+void parse_filter_str(filter_rule_list *listp, const char *rulestr,
+ const filter_rule *template, int xflags);
+void parse_filter_file(filter_rule_list *listp, const char *fname, const filter_rule *template, int xflags);
+char *get_rule_prefix(filter_rule *rule, const char *pat, int for_xfer,
+ unsigned int *plen_ptr);
+void send_filter_list(int f_out);
+void recv_filter_list(int f_in);
+int sparse_end(int f, OFF_T size, int updating_basis_or_equiv);
+int flush_write_file(int f);
+int write_file(int f, int use_seek, OFF_T offset, const char *buf, int len);
+int skip_matched(int fd, OFF_T offset, const char *buf, int len);
+struct map_struct *map_file(int fd, OFF_T len, int32 read_size, int32 blk_size);
+char *map_ptr(struct map_struct *map, OFF_T offset, int32 len);
+int unmap_file(struct map_struct *map);
+void init_flist(void);
+void show_flist_stats(void);
+int link_stat(const char *path, STRUCT_STAT *stp, int follow_dirlinks);
+int change_pathname(struct file_struct *file, const char *dir, int dirlen);
+struct file_struct *make_file(const char *fname, struct file_list *flist,
+ STRUCT_STAT *stp, int flags, int filter_level);
+OFF_T get_device_size(int fd, const char *fname);
+void unmake_file(struct file_struct *file);
+void send_extra_file_list(int f, int at_least);
+struct file_list *send_file_list(int f, int argc, char *argv[]);
+struct file_list *recv_file_list(int f, int dir_ndx);
+void recv_additional_file_list(int f);
+int flist_find(struct file_list *flist, struct file_struct *f);
+int flist_find_name(struct file_list *flist, const char *fname, int want_dir_match);
+int flist_find_ignore_dirness(struct file_list *flist, struct file_struct *f);
+void clear_file(struct file_struct *file);
+void flist_free(struct file_list *flist);
+int f_name_cmp(const struct file_struct *f1, const struct file_struct *f2);
+int f_name_has_prefix(const struct file_struct *f1, const struct file_struct *f2);
+char *f_name_buf(void);
+char *f_name(const struct file_struct *f, char *fbuf);
+struct file_list *get_dirlist(char *dirname, int dlen, int flags);
+int unchanged_attrs(const char *fname, struct file_struct *file, stat_x *sxp);
+void itemize(const char *fnamecmp, struct file_struct *file, int ndx, int statret,
+ stat_x *sxp, int32 iflags, uchar fnamecmp_type,
+ const char *xname);
+int quick_check_ok(enum filetype ftype, const char *fn, struct file_struct *file, STRUCT_STAT *st);
+int atomic_create(struct file_struct *file, char *fname, const char *slnk, const char *hlnk,
+ dev_t rdev, stat_x *sxp, int del_for_flag);
+void check_for_finished_files(int itemizing, enum logcode code, int check_redo);
+void generate_files(int f_out, const char *local_name);
+struct hashtable *hashtable_create(int size, int key64);
+void hashtable_destroy(struct hashtable *tbl);
+void *hashtable_find(struct hashtable *tbl, int64 key, void *data_when_new);
+uint32_t hashlittle(const void *key, size_t length);
+int64 hashlittle2(const void *key, size_t length);
+void init_hard_links(void);
+struct ht_int64_node *idev_find(int64 dev, int64 ino);
+void idev_destroy(void);
+void match_hard_links(struct file_list *flist);
+int hard_link_check(struct file_struct *file, int ndx, char *fname,
+ int statret, stat_x *sxp, int itemizing,
+ enum logcode code);
+int hard_link_one(struct file_struct *file, const char *fname,
+ const char *oldname, int terse);
+void finish_hard_link(struct file_struct *file, const char *fname, int fin_ndx,
+ STRUCT_STAT *stp, int itemizing, enum logcode code,
+ int alt_dest);
+int skip_hard_link(struct file_struct *file, struct file_list **flist_p);
+void reduce_iobuf_size(xbuf *out, size_t new_size);
+void restore_iobuf_size(xbuf *out);
+void noop_io_until_death(void);
+int send_msg(enum msgcode code, const char *buf, size_t len, int convert);
+void send_msg_int(enum msgcode code, int num);
+void send_msg_success(const char *fname, int num);
+void io_set_sock_fds(int f_in, int f_out);
+void set_io_timeout(int secs);
+void increment_active_files(int ndx, int itemizing, enum logcode code);
+int get_redo_num(void);
+int get_hlink_num(void);
+void start_filesfrom_forwarding(int fd);
+int read_line(int fd, char *buf, size_t bufsiz, int flags);
+void read_args(int f_in, char *mod_name, char *buf, size_t bufsiz, int rl_nulls,
+ char ***argv_p, int *argc_p, char **request_p);
+BOOL io_start_buffering_out(int f_out);
+BOOL io_start_buffering_in(int f_in);
+void io_end_buffering_in(BOOL free_buffers);
+void io_end_buffering_out(BOOL free_buffers);
+void maybe_flush_socket(int important);
+void maybe_send_keepalive(time_t now, int flags);
+void start_flist_forward(int ndx);
+void stop_flist_forward(void);
+void wait_for_receiver(void);
+unsigned short read_shortint(int f);
+int32 read_int(int f);
+uint32 read_uint(int f);
+int32 read_varint(int f);
+int64 read_varlong(int f, uchar min_bytes);
+int64 read_longint(int f);
+void read_buf(int f, char *buf, size_t len);
+void read_sbuf(int f, char *buf, size_t len);
+uchar read_byte(int f);
+int read_vstring(int f, char *buf, int bufsize);
+void read_sum_head(int f, struct sum_struct *sum);
+void write_sum_head(int f, struct sum_struct *sum);
+void io_flush(int flush_type);
+void write_shortint(int f, unsigned short x);
+void write_int(int f, int32 x);
+void write_varint(int f, int32 x);
+void write_varlong(int f, int64 x, uchar min_bytes);
+void write_longint(int f, int64 x);
+void write_bigbuf(int f, const char *buf, size_t len);
+void write_buf(int f, const char *buf, size_t len);
+void write_sbuf(int f, const char *buf);
+void write_byte(int f, uchar c);
+void write_vstring(int f, const char *str, int len);
+void write_ndx(int f, int32 ndx);
+int32 read_ndx(int f);
+int read_line_old(int fd, char *buf, size_t bufsiz, int eof_ok);
+void io_printf(int fd, const char *format, ...);
+void io_start_multiplex_out(int fd);
+void io_start_multiplex_in(int fd);
+int io_end_multiplex_in(int mode);
+int io_end_multiplex_out(int mode);
+void start_write_batch(int fd);
+void stop_write_batch(void);
+void reset_daemon_vars(void);
+int lp_load(char *pszFname, int globals_only);
+BOOL set_dparams(int syntax_check_only);
+int lp_num_modules(void);
+int lp_number(char *name);
+void log_init(int restart);
+void logfile_close(void);
+void logfile_reopen(void);
+void rwrite(enum logcode code, const char *buf, int len, int is_utf8);
+void rprintf(enum logcode code, const char *format, ...);
+void rsyserr(enum logcode code, int errcode, const char *format, ...);
+void rflush(enum logcode code);
+void remember_initial_stats(void);
+int log_format_has(const char *format, char esc);
+void log_item(enum logcode code, struct file_struct *file, int iflags, const char *hlink);
+void maybe_log_item(struct file_struct *file, int iflags, int itemizing, const char *buf);
+void log_delete(const char *fname, int mode);
+void log_exit(int code, const char *file, int line);
+pid_t wait_process(pid_t pid, int *status_ptr, int flags);
+int shell_exec(const char *cmd);
+void write_del_stats(int f);
+void read_del_stats(int f);
+int child_main(int argc, char *argv[]);
+void start_server(int f_in, int f_out, int argc, char *argv[]);
+int client_run(int f_in, int f_out, pid_t pid, int argc, char *argv[]);
+void remember_children(UNUSED(int val));
+const char *get_panic_action(void);
+int main(int argc,char *argv[]);
+void match_sums(int f, struct sum_struct *s, struct map_struct *buf, OFF_T len);
+void match_report(void);
+void limit_output_verbosity(int level);
+void reset_output_levels(void);
+void negate_output_levels(void);
+void option_error(void);
+char *alt_dest_opt(int type);
+int parse_arguments(int *argc_p, const char ***argv_p);
+char *safe_arg(const char *opt, const char *arg);
+void server_options(char **args, int *argc_p);
+int maybe_add_e_option(char *buf, int buf_len);
+char *check_for_hostspec(char *s, char **host_ptr, int *port_ptr);
+int pm_process( char *FileName,
+ BOOL (*sfunc)(char *),
+ BOOL (*pfunc)(char *, char *) );
+pid_t piped_child(char **command, int *f_in, int *f_out);
+pid_t local_child(int argc, char **argv, int *f_in, int *f_out,
+ int (*child_main)(int, char*[]));
+void progress_init(void);
+void set_current_file_index(struct file_struct *file, int ndx);
+void instant_progress(const char *fname);
+void end_progress(OFF_T size);
+void show_progress(OFF_T ofs, OFF_T size);
+int get_tmpname(char *fnametmp, const char *fname, BOOL make_unique);
+int open_tmpfile(char *fnametmp, const char *fname, struct file_struct *file);
+int recv_files(int f_in, int f_out, char *local_name);
+void setup_iconv(void);
+int iconvbufs(iconv_t ic, xbuf *in, xbuf *out, int flags);
+void send_protected_args(int fd, char *args[]);
+int read_ndx_and_attrs(int f_in, int f_out, int *iflag_ptr, uchar *type_ptr, char *buf, int *len_ptr);
+void free_sums(struct sum_struct *s);
+mode_t dest_mode(mode_t flist_mode, mode_t stat_mode, int dflt_perms,
+ int exists);
+int set_file_attrs(const char *fname, struct file_struct *file, stat_x *sxp,
+ const char *fnamecmp, int flags);
+void sig_int(int sig_num);
+int finish_transfer(const char *fname, const char *fnametmp,
+ const char *fnamecmp, const char *partialptr,
+ struct file_struct *file, int ok_to_set_time,
+ int overwriting_basis);
+struct file_list *flist_for_ndx(int ndx, const char *fatal_error_loc);
+const char *who_am_i(void);
+void successful_send(int ndx);
+void send_files(int f_in, int f_out);
+int try_bind_local(int s, int ai_family, int ai_socktype,
+ const char *bind_addr);
+int open_socket_out(char *host, int port, const char *bind_addr, int af_hint);
+int open_socket_out_wrapped(char *host, int port, const char *bind_addr, int af_hint);
+int is_a_socket(int fd);
+void start_accept_loop(int port, int (*fn)(int, int));
+void set_socket_options(int fd, char *options);
+int do_unlink(const char *path);
+int do_symlink(const char *lnk, const char *path);
+ssize_t do_readlink(const char *path, char *buf, size_t bufsiz);
+int do_link(const char *old_path, const char *new_path);
+int do_lchown(const char *path, uid_t owner, gid_t group);
+int do_mknod(const char *pathname, mode_t mode, dev_t dev);
+int do_rmdir(const char *pathname);
+int do_open(const char *pathname, int flags, mode_t mode);
+int do_chmod(const char *path, mode_t mode);
+int do_rename(const char *old_path, const char *new_path);
+int do_ftruncate(int fd, OFF_T size);
+void trim_trailing_slashes(char *name);
+int do_mkdir(char *path, mode_t mode);
+int do_mkstemp(char *template, mode_t perms);
+int do_stat(const char *path, STRUCT_STAT *st);
+int do_lstat(const char *path, STRUCT_STAT *st);
+int do_fstat(int fd, STRUCT_STAT *st);
+OFF_T do_lseek(int fd, OFF_T offset, int whence);
+int do_setattrlist_times(const char *path, STRUCT_STAT *stp);
+int do_setattrlist_crtime(const char *path, time_t crtime);
+time_t get_create_time(const char *path, STRUCT_STAT *stp);
+int do_SetFileTime(const char *path, time_t crtime);
+int do_utimensat(const char *path, STRUCT_STAT *stp);
+int do_lutimes(const char *path, STRUCT_STAT *stp);
+int do_utimes(const char *path, STRUCT_STAT *stp);
+int do_utime(const char *path, STRUCT_STAT *stp);
+OFF_T do_fallocate(int fd, OFF_T offset, OFF_T length);
+int do_punch_hole(int fd, OFF_T pos, OFF_T len);
+int do_open_nofollow(const char *pathname, int flags);
+int secure_relative_open(const char *basedir, const char *relpath, int flags, mode_t mode);
+int do_open_checklinks(const char *pathname);
+void init_compression_level(void);
+void set_compression(const char *fname);
+void send_token(int f, int32 token, struct map_struct *buf, OFF_T offset,
+ int32 n, int32 toklen);
+int32 recv_token(int f, char **data);
+void see_token(char *data, int32 toklen);
+const char *uid_to_user(uid_t uid);
+const char *gid_to_group(gid_t gid);
+int user_to_uid(const char *name, uid_t *uid_p, BOOL num_ok);
+int group_to_gid(const char *name, gid_t *gid_p, BOOL num_ok);
+uid_t match_uid(uid_t uid);
+gid_t match_gid(gid_t gid, uint16 *flags_ptr);
+const char *add_uid(uid_t uid);
+const char *add_gid(gid_t gid);
+void send_id_lists(int f);
+uid_t recv_user_name(int f, uid_t uid);
+gid_t recv_group_name(int f, gid_t gid, uint16 *flags_ptr);
+void recv_id_list(int f, struct file_list *flist);
+void parse_name_map(char *map, BOOL usernames);
+const char *getallgroups(uid_t uid, item_list *gid_list);
+void print_rsync_version(enum logcode f);
+void usage(enum logcode F);
+void daemon_usage(enum logcode F);
+const char *rsync_version(void);
+const char *default_cvsignore(void);
+void set_nonblocking(int fd);
+void set_blocking(int fd);
+int fd_pair(int fd[2]);
+void print_child_argv(const char *prefix, char **cmd);
+int set_times(const char *fname, STRUCT_STAT *stp);
+int make_path(char *fname, int flags);
+int full_write(int desc, const char *ptr, size_t len);
+int copy_file(const char *source, const char *dest, int tmpfilefd, mode_t mode);
+int robust_unlink(const char *fname);
+int robust_rename(const char *from, const char *to, const char *partialptr,
+ int mode);
+pid_t do_fork(void);
+void kill_all(int sig);
+int lock_range(int fd, int offset, int len);
+int glob_expand(const char *arg, char ***argv_p, int *argc_p, int *maxargs_p);
+void glob_expand_module(char *base1, char *arg, char ***argv_p, int *argc_p, int *maxargs_p);
+void strlower(char *s);
+char *conf_strtok(char *str);
+size_t pathjoin(char *dest, size_t destsize, const char *p1, const char *p2);
+size_t stringjoin(char *dest, size_t destsize, ...);
+int count_dir_elements(const char *p);
+int clean_fname(char *name, int flags);
+char *sanitize_path(char *dest, const char *p, const char *rootdir, int depth, int flags);
+int change_dir(const char *dir, int set_path_only);
+char *normalize_path(char *path, BOOL force_newbuf, unsigned int *len_ptr);
+char *full_fname(const char *fn);
+char *partial_dir_fname(const char *fname);
+int handle_partial_dir(const char *fname, int create);
+int unsafe_symlink(const char *dest, const char *src);
+char *timestring(time_t t);
+int same_time(time_t f1_sec, unsigned long f1_nsec, time_t f2_sec, unsigned long f2_nsec);
+int _Insure_trap_error(int a1, int a2, int a3, int a4, int a5, int a6);
+const char *find_filename_suffix(const char *fn, int fn_len, int *len_ptr);
+uint32 fuzzy_distance(const char *s1, unsigned len1, const char *s2, unsigned len2, uint32 upperlimit);
+struct bitbag *bitbag_create(int max_ndx);
+void bitbag_set_bit(struct bitbag *bb, int ndx);
+void bitbag_clear_bit(struct bitbag *bb, int ndx);
+int bitbag_check_bit(struct bitbag *bb, int ndx);
+int bitbag_next_bit(struct bitbag *bb, int after);
+void flist_ndx_push(flist_ndx_list *lp, int ndx);
+int flist_ndx_pop(flist_ndx_list *lp);
+void *expand_item_list(item_list *lp, size_t item_size, const char *desc, int incr);
+void force_memzero(void *buf, size_t len);
+int msleep(int t);
+void *my_alloc(void *ptr, size_t num, size_t size, const char *file, int line);
+const char *sum_as_hex(int csum_type, const char *sum, int flist_csum);
+NORETURN void _out_of_memory(const char *msg, const char *file, int line);
+NORETURN void _overflow_exit(const char *msg, const char *file, int line);
+const char *src_file(const char *file);
+void free_xattr(stat_x *sxp);
+int get_xattr(const char *fname, stat_x *sxp);
+int copy_xattrs(const char *source, const char *dest);
+int send_xattr(int f, stat_x *sxp);
+int xattr_diff(struct file_struct *file, stat_x *sxp, int find_all);
+void send_xattr_request(const char *fname, struct file_struct *file, int f_out);
+int recv_xattr_request(struct file_struct *file, int f_in);
+void receive_xattr(int f, struct file_struct *file);
+void cache_tmp_xattr(struct file_struct *file, stat_x *sxp);
+void uncache_tmp_xattrs(void);
+int set_xattr(const char *fname, const struct file_struct *file, const char *fnamecmp, stat_x *sxp);
+char *get_xattr_acl(const char *fname, int is_access_acl, size_t *len_p);
+int set_xattr_acl(const char *fname, int is_access_acl, const char *buf, size_t buf_len);
+int del_def_xattr_acl(const char *fname);
+int get_stat_xattr(const char *fname, int fd, STRUCT_STAT *fst, STRUCT_STAT *xst);
+int set_stat_xattr(const char *fname, struct file_struct *file, mode_t new_mode);
+int x_stat(const char *fname, STRUCT_STAT *fst, STRUCT_STAT *xst);
+int x_lstat(const char *fname, STRUCT_STAT *fst, STRUCT_STAT *xst);
+int x_fstat(int fd, STRUCT_STAT *fst, STRUCT_STAT *xst);
+char get_number_separator(void);
+char get_decimal_point(void);
+int sys_gettimeofday(struct timeval *tv);
+char *do_big_num(int64 num, int human_flag, const char *fract);
+char *do_big_dnum(double dnum, int human_flag, int decimal_digits);
+char *lp_bind_address(void);
+char *lp_daemon_chroot(void);
+char *lp_daemon_gid(void);
+char *lp_daemon_uid(void);
+char *lp_motd_file(void);
+char *lp_pid_file(void);
+char *lp_socket_options(void);
+int lp_listen_backlog(void);
+int lp_rsync_port(void);
+BOOL lp_proxy_protocol(void);
+char *lp_auth_users(int module_id);
+char *lp_charset(int module_id);
+char *lp_comment(int module_id);
+char *lp_dont_compress(int module_id);
+char *lp_early_exec(int module_id);
+char *lp_exclude(int module_id);
+char *lp_exclude_from(int module_id);
+char *lp_filter(int module_id);
+char *lp_gid(int module_id);
+char *lp_hosts_allow(int module_id);
+char *lp_hosts_deny(int module_id);
+char *lp_include(int module_id);
+char *lp_include_from(int module_id);
+char *lp_incoming_chmod(int module_id);
+char *lp_lock_file(int module_id);
+char *lp_log_file(int module_id);
+char *lp_log_format(int module_id);
+char *lp_name(int module_id);
+char *lp_name_converter(int module_id);
+char *lp_outgoing_chmod(int module_id);
+char *lp_postxfer_exec(int module_id);
+char *lp_prexfer_exec(int module_id);
+char *lp_refuse_options(int module_id);
+char *lp_secrets_file(int module_id);
+char *lp_syslog_tag(int module_id);
+char *lp_uid(int module_id);
+char *lp_path(int module_id);
+char *lp_temp_dir(int module_id);
+int lp_max_connections(int module_id);
+int lp_max_verbosity(int module_id);
+int lp_timeout(int module_id);
+int lp_syslog_facility(int module_id);
+BOOL lp_fake_super(int module_id);
+BOOL lp_forward_lookup(int module_id);
+BOOL lp_ignore_errors(int module_id);
+BOOL lp_ignore_nonreadable(int module_id);
+BOOL lp_list(int module_id);
+BOOL lp_read_only(int module_id);
+BOOL lp_reverse_lookup(int module_id);
+BOOL lp_strict_modes(int module_id);
+BOOL lp_transfer_logging(int module_id);
+BOOL lp_write_only(int module_id);
+BOOL lp_munge_symlinks(int module_id);
+BOOL lp_numeric_ids(int module_id);
+BOOL lp_open_noatime(int module_id);
+BOOL lp_use_chroot(int module_id);
--- a/rounding.h 1970-01-01 04:00:00.000000000 +0400
+++ b/rounding.h 2026-05-11 10:27:12.923736937 +0400
@@ -0,0 +1 @@
+#define EXTRA_ROUNDING 1
--- a/shconfig 1970-01-01 04:00:00.000000000 +0400
+++ b/shconfig 2026-05-11 10:27:03.792448328 +0400
@@ -0,0 +1,15 @@
+#! /bin/sh
+
+# config.sh.in
+
+# This file is processed by config.status to produce config.status,
+# containing autoconf-determined values needed by the test scripts.
+
+ECHO_T=""
+ECHO_N="-n"
+ECHO_C=""
+HOST_OS="linux-gnu"
+SHELL_PATH="/usr/bin/sh"
+FAKEROOT_PATH="/usr/bin/fakeroot"
+
+export ECHO_T ECHO_N ECHO_C HOST_OS SHELL_PATH FAKEROOT_PATH