proto_detail: FD leak and NULL filename_work in error log

bfd: three bugs — NULL deref on fr_pair_copy, FD leak on setsockopt fail, inverted wraparound condition

regex.c: missing NULL check after retry talloc_array in regex_substitute

pcap.c: unchecked pcap_open_dead NULL in STDIO_OUT; handle leaked on dump_open fail

fix(perm): wrong sticky-bit mask, and sc_len assigned instead of len in #else blocks

lib/ldap: off-by-one in suffix check, double-backslash normalisation, NULL dereference in fr_ldap_map_do

listen/control/proto_control_unix.c: fopencookie return values unchecked, NULL passed to setvbuf

snmp.c: fix index underflow, two NULL derefs, and unchecked alloc return values

rlm_sqlippool: missing NULL check for query in IPPOOL_ALLOC_FIND case

state.c: fix state leak

map: fix size_t underflow in map_afrom_fields when rhs is a lone unclosed quote

rlm_sql: ignored return value from escape function allows unescaped SQL

rlm_unbound: RCODEERROR cases are dead code (placed after default: return)

rlm_krb5: fix use-after-free — move krb5_free_context to after keytab/ccache close

rlm_attr_filter: fix NULL dereference on nullable key

rlm_unpack: fix stale 'used' value in loop boundary check causes incorrect break condition

vmps: close sockfd before return on setsockopt failure

ldap_sync: fix off-by-one in packet_id bounds assertion

unlang/call: add missing default case for pair_update_reply() allocation failure

atexit.h: guard NULL _init call in non-threaded fr_atexit_global_once macro

atexit.c: fix memory leak of fr_atexit_global and unsigned return -1 in disarm

lib/util/fifo: fix off-by-one in ring-buffer wrap check (> → >=)

cap.c: fr_cap_is_enabled ignores set parameter, always queries CAP_EFFECTIVE

log.c: fix three stderr capture/restore bugs — wrong FD slots and wrong context struct

exec.c: fix stderr_pipe FD leak when fork fails in fr_exec_fork_wait

lib/ldap/util: fix double-backslash normalise_dn outputs extra char; fix fr_ldap_common_dn off-by-one skips first char of part

lib/ldap: guard ldap_msg_types[] lookup against out-of-bounds and NULL entries

lib/ldap: fix swapped pointer arguments in _ldap_connection_free debug message

lib/ldap: free bind_ctx in _ldap_bind_io_read error paths

lib/ldap: fix reversed singular/plural in ldap_trunk_search_results_debug

lib/json: check return value of fr_value_box_bstrndup in fr_json_object_to_value_box

eap_aka_sim/xlat: dot-notation xlat aliases registered but never unregistered

eap_aka_sim/xlat: NULL dereference in id_method and id_type xlat handlers if dict enum not found

eap_aka_sim/id: fix wrong tag bytes for FASTAUTH in hint_byte_matrix

eap/chbind: remove dead attr_message_authenticator check in chbind_build_response

lib/server/exec_legacy: fix off-by-one OOB write in radius_exec_program_legacy

remove tmpl from fuzzer CI checks

it's randomly failing, and preventing other changes from being
merged

add one more suppression for leaks inside of the llvm fuzzer

add config file corpus

add xlat corpus

add tmpl corpus

add fuzzer corpus for base16_32_64 tests

add tmpl fuzzer

oss-fuzz: Add new fuzzer targetting base16/32/64 encode/decode

Signed-off-by: Arthur Chan <arthur.chan@adalogics.com>
With manual merges for new location of the fuzzer

catch more corner cases of constant strings when tokenizing

update to commit b17b28a02

return 0 for pop case

the caller already checks for this.  Previously, all paths would
return 1, which doesn't make sense

make cf_section_dup() iterative

and add assertions that we can't copy the inputs back to the
inputs

more stringent checks on references

we can't refer to any parent, otherwise we end up copying ourselves

invalid control characters are errors

track reference braces.

so we can tell the difference between "close the at reference"
and "close the parent section"

turn assert into run-time check

Add connection subsection to rlm_sql sample config

And correct comment about `start` - failure to open connections no
longer stops the server from starting.

fix end conditions on fr_skip_*() functions

add cf_file_read_buffer(), and use it in the fuzzer

build CF and xlat fuzzers, but don't run them in CI

so that we can at least try to see what's up

we should call tmpl_global_init(), too

disable xlat fuzzer

there are still issues with the code, and the fuzzer failures are
causing other patches to not be merged.

make xlat fuzzer use the common framework

and update it so that it actually runs

clarify errors and clean up checks for invalid name

the fuzzer showed that inputs like "[0]" were parsed, but the
tmpl_t wasn't properly updated.

This change makes the errors less opaque, and tightens the
restrictions on invalid names.

make "util" use the common framework

which is simpler, and less code

move common code to common function

we need to call tmpl_global_init before parsing tmpls

if the tmpl is unresolved, set the type to UNRESOLVED

merge adjacent constant strings in xlat_tokenize_input()

remove unnecessary rule

typo

free on error

tighten restrictions on decoding

* reject indefinite length forms for all tags
* reject lengths which are non minimal

be more precise for time parsing

* if there's a '.' but no subseconds, that's an error
* if there are subseconds, check that there's a trailing 'Z'

clean up vp on error path

it's in tmp_ctx, so it's not leaked. but it's still good to lower
peak memory usage

put data for different roots into named subdirectories

so that we can fuzz different parts of DER

hoist "create fuzzer dir" code into separate function

separate "base" fuzzer_dir from "current" or "proto" dir

in preparation for allowed DER to have different bases

rename variable holding FD to be fuzzer_fd

there's already a fuzzer_dir which is a string

simplify definitions of allowed_chars

to make them clearer, and to have more re-use

pause subsequent connections from dynamic clients

while the first one is being defined

and then either allow or deny all subsequent connections

Revert "fix multiple connections from dynamic clients"

This reverts commit 01748d3363b6a38f92eef3cf7ff8c638a6e06962.

multi-server: bump radenv to 1.0.2

The published package is now named 'radenv' and lives under
pypi.inkbridge.io/radenv/. Script entrypoints follow the same rename:
multi-server-test{,-config} -> radenv{,-config}.

See InkbridgeNetworks/radenv@v1.0.2 for the upstream rename.

multi-server: install radenv from inkbridge pypi instead of git clone

Drop the github.com/InkbridgeNetworks/radenv.git checkout + 'make
configure' dance and install the framework as a pip package from the
inkbridge index instead. Pinned version stays in RADENV_VERSION so
bumps are a one-line change.

  --extra-index-url https://pypi.inkbridge.io/ freeradius-multi-server==1.0.1

The inkbridge host already serves the PEP 503 simple listing at its
root, so no /simple/ suffix. --extra-index-url keeps the default
PyPI fallback for transitive deps.

Switches the python3 -m src.<module> invocations over to the
multi-server-test / multi-server-test-config entrypoints that the
sdist exposes via [project.scripts]; the cd / venv-activate dance
in front of every call goes away.

Also bumps actions/upload-artifact from v4 (Node.js 20, deprecated
2026-06-02) to v6 (Node.js 24) so ci-multi-server-tests stops
emitting the deprecation warning on every run.

Closes #5860

profiling image: stage /docker-entrypoint.sh so it's a drop-in for service

src/tests/multi-server/environments/kafka.yml.j2 (and the other env
templates) override the Dockerfile entrypoint with a bash wrapper that
still execs /docker-entrypoint.sh. The service image stages that file
via service.{deb,rpm}.m4 but the profiling image didn't, so the
kafka-producer1 container exited 127 ("command not found") in
profiling-mode multi-server runs.

Add the same COPY + chmod to common.freeradius-profile-build.m4. Leave
the per-distro profiling.{deb,rpm}.m4 EXPOSE / CMD (sleep loop) alone
since compose overrides them anyway.

multi-server / docker: cleaner path layout and plain-ascii arrows

Reorder the profiling-results path so branch / commit / run-index
come before the test name:

  before: prof-results/<test>/<mode>/<branch>/<commit>/<run-index>
  after:  prof-results/<branch>/<commit>/<run-index>/<test>/<mode>

The run-index now counts at the branch/commit level instead of per
(test, mode), so a single CI invocation's parallel tests share an
index and a re-run of the same commit gets the next index.

Also swap the unicode '->' arrows in docker.mk's DOCKER_BUILD header
for plain '>' to match the BUILD echo style.

profiling image: install with --prefix=/usr to match deb/rpm layout

The profiling Dockerfile chain used the default ./configure prefix
(/usr/local), so radclient / radiusd / etc. ended up under
/usr/local/bin and /usr/local/sbin while the service image (deb/rpm
install) puts them under /usr/bin and /usr/sbin. Test fixtures had
to either drop absolute paths or branch on mode.

Pass --prefix=/usr so the source build lands binaries at the same
absolute paths as the production packages. Update the radiusd ->
freeradius alias symlink to match. Restore /usr/bin/radclient in the
proxy-accept and proxy-multihop-accept test templates now that both
modes resolve it the same way.

multi-server: invoke radclient from PATH; surface docker build log on failure

The proxy-accept and proxy-multihop-accept test templates were calling
/usr/bin/radclient directly. That path is correct for service mode
(deb-installed FR) but the profiling image builds from source with the
default ./configure prefix, so radclient lands at /usr/local/bin/radclient
and the exec failed with 'No such file or directory'. Drop the absolute
path and rely on $PATH so both modes work.

Also add the same Show-docker-build-log failure step to
ci-multi-server-tests.yml that docker-refresh / docker-crossbuild /
docker-service already have, so the apt errors from a failed
crossbuild / profiling-deps build aren't trapped in a per-job runner
log file.

scripts/docker/docker.mk: switch the PULL echo from 'latest <- registry'
to 'latest < registry' to match the BUILD echo's plain redirect style.

common.deb.dbgsym: tolerate ddebs version skew per-package

ddebs.ubuntu.com and debian-debug rebuild dbgsyms slower than the
matching main package gets a security update. On any given day a
handful of entries are in skew: dbgsym pinned to -buildN while main
is at -ubuntuN.M.K, so an apt-get install of the full list fails with
unmet dependencies. Recent refresh runs caught 9 packages mid-skew on
jammy in one snapshot.

Switch back to per-package install with a WARNING fallback. Skewed
entries are logged loudly so missing symbols stay visible, and the
remaining ~15 of ~24 dbgsyms still land. The next refresh picks up
the previously-skewed ones once ddebs catches up.

docker-refresh: build crossbuild from upstream OS, run freeradius in parallel with CI bases

process-freeradius-images was overriding crossbuild's FROM to
self-hosted-ci-<distro> via CB_FROM_* env vars to reuse the slim CI
toolchain layer. The reuse saved a minute or two of apt-install per
distro at the cost of a hard dependency on process-ci-images
(crossbuild's FROM had to exist in the registry before the build).

Drop the CB_FROM_* block so crossbuild builds from the upstream
ubuntu/debian/rocky base directly, same path service uses. Trades a
modest build-time increase for parallelism with process-ci-images
and removes the cross-job FROM-chain that broke during the
self-hosted-{deb,rocky} -> self-hosted-ci rename.

docker-refresh: serialise concurrent refresh runs

Add a workflow-level concurrency group with cancel-in-progress: false
so a second refresh trigger (push to master + a manual workflow_dispatch,
two manual triggers in quick succession, or the nightly schedule
overlapping a push) queues behind the running one instead of starting
a second parallel refresh.

cancel-in-progress is left false: an in-flight refresh that's halfway
through publishing :latest tags shouldn't be torn down by the next
trigger; let it finish, then run the queued one which re-publishes
everything cleanly.

docker-refresh: chain freeradius-images on ci-images

process-freeradius-images was running in parallel with
process-ci-images, both gated on process-docker-cli. crossbuild
FROMs self-hosted-ci-<distro>:latest and resolved that via the
previous nightly's registry copy. The rename from
self-hosted-{deb-,rocky}<distro> to self-hosted-ci-<distro> means
no previous nightly has published the new tag yet, so the parallel
crossbuild step now fails with 'manifest not found' on the FROM.

Serialise: freeradius-images needs ci-images. One extra wait per
refresh in exchange for a working FROM chain through any future
rename.

docker-refresh: rename CI bases to self-hosted-ci-<distro>, surface build log on failure

The slim CI build bases (built from scripts/docker/build/<distro>/Dockerfile.ci
and consumed by ci-deb.yml / ci-rpm.yml) were named inconsistently:
the rpm side ran as self-hosted-rocky{9,10} and the deb side as
self-hosted-deb-{debian12,debian13,debiansid,ubuntu22,ubuntu24,ubuntu26}.
Unify on self-hosted-ci-<distro> across both families. self-hosted-ubuntu24
(no -ci-) stays as the GH runner host image so the two roles are
distinguishable.

Updates the matrix entries in docker-refresh.yml, the CB_FROM_* env
in process-freeradius-images and docker-crossbuild.yml, and the
BUILD_IMAGE strings in ci-deb.yml / ci-rpm.yml.

Also re-adds the Show docker build logs failure step to
process-freeradius-images (got lost in an earlier rewrite). Without
it the actual apt errors from the dbgsym install stay hidden in
build/docker/build.<os>.profiling-deps on the runner.

docker-refresh: force bash for container-based jobs

When a GH Actions job declares a container:, the per-step run: shell
defaults to /bin/sh (dash on the cli image's debian base). The Create
build dependency package step uses $(stat -c'%u:%g' .git) inside an
unquoted heredoc, and dash fails to parse that with a cryptic
'Syntax error: "(" unexpected'. Pin shell: bash for both
process-ci-images and process-freeradius-images.

Also renames process-images to process-ci-images for clarity now
that it only covers the CI runner / build bases plus pull-through
caches.

docker-refresh: rebuild freeradius-build-deps.deb for self-hosted-ubuntu24

scripts/ci/docker/Dockerfile COPYs /freeradius-build-deps.deb and
/freeradius-build-deps-extra.deb into the runner host image. After the
matrix split the build step was orphaned in process-host-bases so the
files were never generated, and the docker build failed with a 'cache
key not found' on the COPY. Re-add the dep-pkg step in
process-host-bases, gated on a needs_build_deps flag on the ubuntu24
matrix entry.

docker-refresh: build dind + cli first, run the rest under fresh dind

Split docker-refresh into a four-stage pipeline so the freshly built
dind sidecar and docker-cli job-container are in the registry before
anything else uses them.

  process-host-bases    raw host, parallel: self-hosted-ubuntu24
                        (alias self-hosted) and self-hosted-docker-dind
  process-docker-cli    raw host, needs process-host-bases: builds
                        self-hosted-docker-cli, which FROMs self-hosted
  process-images        dind + cli, needs process-docker-cli, parallel:
                        the remaining CI bases (rocky/deb-*) plus the
                        mariadb / postgres / 389ds pull-through caches
  process-freeradius-images
                        dind + cli, needs process-docker-cli, parallel:
                        the freeradius4-{crossbuild,profiling-deps,
                        service} chain per distro

Stages 3 and 4 use fresh dind + cli from this run instead of the
previous cycle's copies. Stages 1 and 2 stay on the raw self-hosted
runner because they're building the very dind/cli they'd otherwise
sit inside.

Also switches all internal-registry logins to docker/login-action@v4
for consistency with the existing Docker Hub login.

docker-refresh: parallelise jobs and fix dbgsym install terminator

Drop the needs: chain in docker-refresh.yml so process-images,
process-docker-cli and process-freeradius-images all start in
parallel. Each job's container and FROM dependencies resolve from
the previous cycle's :latest, so a one-cycle staleness is acceptable.
Rename process-derived-images to process-docker-cli since it builds
exactly one image.

Fix common.deb.dbgsym.m4 to terminate the apt-get install reliably:
move libc6-dbg to the tail as the unconditional last token. On sid
and resolute the libxml2/libidn12/python ifelse blocks all evaluate
to empty, which left the previous-to-last package's trailing
backslash joining the apt-get install command with the next RUN.
Buildkit fed "RUN git clone FlameGraph ..." to apt as a package name
and exited 100. Also corrects the codename test from forky to sid to
match Dockerfile.m4's OS_CODENAME mapping for debiansid.

Merge profiling-multi-server-fixes into developer/arr2036

Pulls in the docker-refresh, profiling-deps split, /etc/freeradius
standardisation, ddebs version-skew tolerance, and matrix display
name work from profiling-multi-server-fixes. Resolves conflicts in
docker.mk and dockerfile.mk by keeping the cleaner per-type list
factoring from developer/arr2036 and extending it with profiling-deps.

Adds display: fields to every docker-refresh.yml matrix entry so the
GH Actions UI shows the actual image identity instead of the entry
dict serialisation, renames the workflow to "Docker refresh", and
labels the FR-image chain job as
freeradius4-{crossbuild,profiling-deps,service}-<os>.

fix multiple connections from dynamic clients

this is a bit of a work-around for now.  the better fix is to
instead have a list of pending connections, and add the later
connections to that list.

add --profile=file options

which sets CPUPROFILE=file, so that we can profile the program
we're executing, and not jlibtool itself

allow for unit_test_module to use profiling, too

most things don't need the gperftools header

it's only needed if the files call the perftools APIs.  And that's
only radmin and dependency.c

remove tests which is racy, and causes CI failures.

depending on timing, the output is either "2" or "3".  and the
framework isn't smart enough (yet) to double-check that. So we
just remove the test.

Move more image building into docker-refresh

common.deb.dbgsym: tolerate apt-get update flakiness for ddebs sources

The dbgsym RUN step did `apt-get update && for pkg in ...`. When the
update step fell over - typically because ddebs.ubuntu.com or
debug.mirrors.debian.org returned a 5xx mid-fetch despite the
Acquire::Retries=3 we set in the toolchain template - the && killed
the whole RUN with exit 100 before any of the per-package installs
ran. The per-package loop already prints a WARNING and continues
for any individual package the cache can't resolve, so letting the
update itself fail soft means partial cache + best-effort installs
still happen rather than tipping the whole image build over.

Concretely: docker.profiling.ubuntu24 stopped building on the
docker-server workflow each time ddebs hiccupped, even though every
dbgsym package is technically optional and FR ships fine without
them.