rlm_kafka: unbox async opaques with talloc_get_type_abort

xctx->inst / xctx->thread / msg->_private are all void pointers that
we know at the call-site should point back at our typed talloc chunks.
Using talloc_get_type_abort turns a subtle type-system hole into a
loud abort at the exact callsite if the opaque ever gets crossed over,
instead of a mystery crash deep in the function body.

The DR callback keeps its NULL-guard first - a NULL opaque is the
documented signal for fire-and-forget produces, so it's part of the
contract, not an error worth asserting on.

rlm_kafka: bridge librdkafka log output into the server log

Register an rd_kafka_conf_set_log_cb on the shared producer conf in
mod_instantiate.  Every per-thread rd_kafka_conf_dup inherits it, so
broker errors, protocol traces, and any categories enabled via the
top-level `debug` knob now feed through the server's ERROR / WARN /
INFO / DEBUG macros with a pre-rendered "rlm_kafka (<instance>)"
prefix instead of going to librdkafka's default stderr sink.

Callback runs on librdkafka's internal threads so no mctx is in
scope; we stash the prefix on rlm_kafka_t at instantiate time and
reach for it via the producer's opaque (rlm_kafka_thread_t) on each
line.

kafka: Basic unreachable test, and cancellation race

kafka: Actually verify the data made it though

tests/multi-server: put kafka-produce back in the CI short suite

The client-cache fix in b56deabae7 ("Create different client cache
lists for TCP and UDP") addresses the underlying reason the
kafka-produce test was timing out in CI - the load-generator's own
Status-Server client lookup was failing the same way as
proxy-multihop-accept's.  Rename short.test.yml back to
short.ci.test.yml so it runs under test.multi-server.ci again.

kafka: Minor style fixes.

Create different client cache lists for TCP and UDP

If we had both TCP and UDP listeners, one would end up getting an empty client list.

tests/multi-server: drop kafka-produce from the CI short suite

The kafka-produce multi-server test runs green locally against a
docker-compose redpanda, but on the shared GitHub Actions runners the
redpanda container fails to reach a healthy state reliably, even with
Redpanda's own dev-container preset.  Rather than leave a perennially
red CI job, rename short.ci.test.yml to short.test.yml so the test
runs from `make test.multi-server` but not from
`test.multi-server.ci`.  Local runs and future dedicated kafka
infrastructure can still exercise it.

ci: skip kafka module tests; switch multi-server broker to dev-container mode

CI rounds 1-2 showed two different redpanda startup failures:

 - In the ci.yml / ci-sanitizers.yml `services:` stanzas, seastar
   exits EINVAL on the self-hosted runners because GitHub Actions
   services give us no way to override the default command line.
   There's no good workaround via `options:` so drop the redpanda
   service container, remove the kafka_test_server passthrough, and
   let the kafka module tests skip cleanly (the existing
   kafka_require_test_server gate already handles the empty-server
   case).  The multi-server kafka-produce test still exercises the
   full produce path end-to-end.

 - The multi-server docker-compose had a hand-rolled list of redpanda
   start flags (`--overprovisioned --smp=1 ... --unsafe-bypass-fsync`)
   which still failed to boot on the shared runner.  Replace it with
   Redpanda's official single-node preset `--mode dev-container`,
   which sets the right seastar probing and IO defaults for a
   containerised CI environment, and keep only the overrides we
   actually need on top (smp/memory/node-id and the advertised
   listener address).

ci: pull redpanda from its own registry and give it a longer health window

Two things tripped up the first CI run on developer/arr2036:

 - The ci.yml and ci-sanitizers.yml workflows pulled redpanda through
   the FreeRADIUS internal docker mirror (docker.internal.networkradius.com),
   but redpandadata/redpanda is not mirrored there, so every job with a
   redpanda service container died at 'Initialize containers'.  Pull
   directly from docker.redpanda.com, matching what the multi-server
   docker-compose already does.

 - The multi-server redpanda service had a 60s start window and 30s of
   retries.  On a busy self-hosted runner that's marginal - we saw
   kafka-produce-short_ci fail the compose-up health gate.  Bump the
   start_period to 120s and extend retries so we allow up to ~4 minutes
   for the broker to come up.

tests/kafka: cover method dispatch forms, keys, binary and edge payloads

Extend the kafka test harness to exercise:

 - method form with explicit name2 (kafka.produce / send / recv .topic)
 - method form with implicit name2 (bare 'kafka' inside a recv section
   that matches a topic named after the packet type)
 - keyed produces (deterministic partitioning by key attr)
 - binary payloads with embedded NULs and high-bit bytes
 - edge-case xlat inputs (empty string, 16 KiB payload, embedded
   control characters, UTF-8 / multibyte)

Topics referenced by the new tests are declared in module.conf so
unknown-topic handling continues to fail at parse time.

rlm_kafka: tighten error handling and xlat register ctx

A grab-bag of cleanups surfaced while refactoring the module:

 - Trust MEM() for talloc-only failures in kafka_topic_thread_handles
   (rb_tree_alloc, rd_kafka_topic_conf_dup).
 - Duplicate topic handle is now an fr_cond_assert_msg - it cannot
   happen if the declared-topic tree was built correctly.
 - Drop the redundant kafka.produce xlat NULL-arg guard; the xlat
   arg parser already enforces required=true.
 - Register the produce xlat against mi->boot rather than mi->data -
   xlat registration happens in bootstrap, before mi->data is
   allocated and mprotected.
 - Move xlat_arg_parser_t below the signal callback so the xlat
   function and its args sit together.
 - Drop the 'rlm_kafka:' prefix from logger calls; the logging layer
   already tags module-originated messages.

rlm_kafka: type value and key as octets

Kafka payloads and keys are opaque byte strings on the wire.  Typing
value/key as FR_TYPE_STRING worked accidentally because fr_value_box_t
carries an explicit length, but it invited NUL-termination or UTF-8
assumptions to creep in from intermediate tmpl expansion.

Switch both the per-topic call_env rules and the xlat value argument
to FR_TYPE_OCTETS, and read .vb_octets instead of .vb_strvalue on the
produce paths.  As a bonus, an integer-typed key attribute now
serialises in network byte order - matching what other Kafka clients
do - so the same numeric key hashes to the same partition regardless
of producer.

rlm_kafka: delegate per-topic value/key parsing to call_env framework

The topic-subsection callback was walking value and key by hand with
cf_pair_find + call_env_parse_pair + call_env_parsed_add +
call_env_parsed_set_tmpl, reimplementing what call_env_parse() already
does when given a rules array pointed at a CONF_SECTION.

Replace the bespoke walker with a single static topic_env[] array and
a recursive call_env_parse() against the topic's subsection.  The
framework handles pair lookup, tmpl compilation, offset writes, and
required/nullable enforcement.

rlm_kafka: drop wordy type and local names

Strip the redundant noise from the type names now that the module is
settled:

    kafka_produce_ctx_t     -> rlm_kafka_msg_ctx_t
    rlm_kafka_produce_env_t -> rlm_kafka_env_t
    rlm_kafka_topic_handle_t -> rlm_kafka_topic_t

Plus the topic handle's rd_kafka_topic_t field and the loop locals in
kafka_topic_thread_handles (rkt/h/tc -> kt/topic_t/ktc).  Pure rename,
no behaviour change.

rlm_kafka: own flush_timeout as a module-level setting

flush_timeout controls how long thread_detach waits for in-flight
messages to drain, which is a policy decision that belongs to the
module using the kafka base library rather than to the library
itself.  Move the CONF_PARSER entry into rlm_kafka's module_config
and store the value on rlm_kafka_t.

Add NO_OUTPUT plug to conf parser, rename FR_CONF_FUNC to FR_CONF_PAIR_GLOBAL to match FR_CONF_SUBSECTION_GLOBAL

Suppress kafka related leaks

Don't overwrite the \0 terminator in fr_globdir_get_path

Don't truncate all the zeros...

Allow CF_IDENT_ANY to work with sections and pairs in CONF_PARSER arrays

Initial commit of kafka producer

rlm_kafka: implement async producer with event-triggered I/O

Replaces the stub with a full async Kafka producer.

* Per-worker rd_kafka_t: each worker thread owns its own producer handle
  so delivery report callbacks always run on the worker that initiated
  the produce. No cross-thread wakeups, no resume races.

* Self-pipe I/O: librdkafka's main queue is wired to a self-pipe via
  rd_kafka_queue_io_event_enable(). The pipe's read end sits in the
  worker's event loop; kafka_fd_readable() drains it then polls the
  producer with a zero-timeout rd_kafka_poll() loop to dispatch DRs
  and broker errors.

* Module surface: kafka.produce method (topic/key/value/headers
  call_env) plus %kafka.produce(topic, value) xlat. Both yield waiting
  for the delivery report and resume with a rcode that distinguishes
  transient failure (fail), permanent rejection (reject), timeout
  (timeout), and success.

* Cancellation: signal handler detaches request from the in-flight
  ctx rather than trying to recall the message (librdkafka has no
  cancel API). dr_msg_cb sees request == NULL and silently frees.
  Safe against dr_msg_cb racing because both fire on the same worker
  thread.

* Shutdown: thread_detach flushes outstanding produces within the
  configured flush_timeout, then drains any queued DRs before tearing
  down the producer. Inflight ctxs whose DRs never arrive are walked
  and their requests nulled out as a belt-and-suspenders.

The module gates off the build system automatically via the existing
src/lib/kafka/all.mk include if librdkafka isn't available.

lib/kafka: expose fr_kafka_conf_t and accessors to modules

Promote kafka_conf_from_cs() and kafka_topic_conf_from_cs() from static
inline to extern, and move the fr_kafka_conf_t / fr_kafka_topic_conf_t
typedefs into the public header so modules can parse kafka config
subsections and hand the resulting rd_kafka_conf_t to rd_kafka_new().

Also fixes a sbuff terminator construction bug in kafka_config_dflt()
where FR_SBUFF_TERM() was being applied to a runtime pointer (sizeof
produces pointer size, not string length), and adds subcs_size metadata
to the topic multi-subsection so cf_parse doesn't assert.

debian: package freeradius-kafka separately

remove unused functions

replace local function with use of standard talloc API

enable suppress_secrets by default, ala v3

Report where too small packets are from in radsniff

Add '-S' and overrides

add cf_pair_replace_or_add()

in preparation for '-S foo.bar=baz'

remove unused code

clarify and separate num objects from pool size

so that the calls to talloc_pooled_object() are clearer

add stack

Just reconnect for UDP which will start the status checks

If the connection is status_checking then status_check packets are allowed

Compare correct time values for last reply within allowed window

If we're verifying replies, we need the original packet

Loop correctly after parsing octet sequence

After `p = end`, p will be pointing to the next character to parse, so
no need to further increment the pointer.

update docs

add more items and sort in alphabetical order

Don't parent temporary dir buffer to ef in exfile_open_mkdir (#5823)

The buffer is always freed before the function returns, so parenting
it to ef implied a lifetime relationship that didn't exist.

Signed-off-by: ethan-thompson <ethan.thompson@networkradius.com>

Disarm rather than delete timers

To avoid repeated freeing / allocating

Ensure parent cleanup timer is disarmed following new TCP connection

Only standard modules register xlats with their own name

Without this, if a virtual server, for example, has the same name as a
module which registers an xlat in its name, then, during server
shutdown, removing the process module for the virtual server attempts to
unregister the xlat which it doesn't own and leads to a seg fault.

Add name to coord_pair

So request names can indicate which coordinator they belong to.

Parent coord_pair_reg off the list of registrations

As with coord_reg, the entry component of the registration will change
as additional modules register coord_pair, which conflicts with module
instance data protection.

Parent coordinator registrations off the list of registrations

When more than one module registers a coordinator, the "previous"
registration changes when the new one is added to the list.  If the
registration is parented off the module instance data then that gets
protected - so a seg fault happens when the second registration is
added.  Parenting the registration off the list removes this issue.

Use fr_dlist_talloc_init to type check entries

Protect CONF_SECTION with const

CONF_SECTION is not changed by map_afrom_cs, so use const

move "run asciidoctor" code

into block where we have asciidoctor

docs-v4: Intergrity check on condition.adoc - fix syntax, added truth table, wordsmithing

docs-v4: Updated copyright message to current year using Alan's perl magic
`perl -p -i -e 's/Copyright \(C\) 2.../Copyright (C) 2026/'  $(git grep -l 'Copyright' $(find doc/antora/ -name "*.adoc" -print))`

Updated the link to the InkBridge Networks website

Correct comment

Pacify Coverity (CID #1691057)

Xlat args will prevent in_head being NULL, but Coverity doesn't follow
that path.

Pacify Coverity (CID #1691058)

Module configuration requires that we there will be a "find" query.

Pacify Coverity (#CID 1691059)

The xlat args will ensure that func is populated, but Coverity doesn't
follow that path.

Allow Message-Authenticator !* 0x00 for "don't send it"

fr_packet_foo -> fr_radius_packet_foo

tweak encoder for static analyzer

which changes the use of the random numbers, and therefore the
tests have to be updated

qualify funtion name with "fr_radius"

we don't need this macro, it's only used once

tweak fr_radius_verify() to keep static analyzer happy

Update action for node.js 24

Add sample config for CRL delta building

Currently `openssl crl` won't take a key on the command line, so `make
rsa/delta.crl` will prompt for the password.

Send CRL-Expire to worker if refresh of expired CRL fails

and expired CRLs are not allowed.

Add time validity options to CRL virtual server

Add process_crl.so to RHEL packaging

Update docs from raddb

Add url option to rlm_crl

To allow pre-fetching of CRLs before they are needed for certificate
verification.

Rework CRL test to handle limitations of unit_test_module

Add %crl.refresh() to forcibly trigger refresh

Plumb coordinator framework into unit_test_module

Add fr_schedule_worker_id_set

Only to be used from test frameworks such as unit_test_module.

Update rlm_crl tests with updated config

Update sample rlm_crl configuration

Convert rlm_crl to use coordinator thread

Add a sample CRL virtual server

Add CRL process module

For a coordinator thread to run requests to fetch CRLs

quiet static analyzer

via using static[256] for fixed-size buffers, among other tweaks

inputfp may be NULL

allocation may fail

tweak checks for digest attributes

clean up radmin

double check return paths, exit codes, messages, etc.

Write "Including files" only in debug2

remove unused code

we don't use the tmpl rules for anything, so we might as well
remove it.

add tests for the dictionary file parser

add fr_dict_afrom_file()

only for testing.  And add wrapper to unit_test_attribute

use different UTF-8 text for test data

remove debug / testing output

add assume() macro

which is a hint to the compiler that a variable can have a
particular value.  It's not an assertion, but it lets the compiler
know that it can make more optimizations based on the given
assumption.

add notes for run-time DNS resolution of client sockets

allow for END PROTOCOL, and END VENDOR too

which is obvious to use.  Because using "BEGIN PROTOCOL" followed
by "END-PROTOCOL" is just weird.

Previously it would complain with an entirely opaque error.

tweak dict_from_file to be a bit more forgiving

look up duplicate number if it's _not_ name-only

default to 0 buffer count

which is the least surprising.  Otherwise it is not at all obvious
why there is a delay.

and enforce min/max limits on the buffer count/delay, so that they
aren't zero

Update linelog examples and documentation

allow radmin to read custom dictionaries, too.

the server and radclient assume that the RADIUS protocol is loaded
before reading raddb/dictionary.  So radmin should do that, too