look for and compile a per-server "timeout" section

don't insert static clients into the dynamic client list

distinguish frame_signal and interpret_signal

when we hit a timeout, we signal the frames to cancel.  If pushing
the timer section onto the stack fails, we signal the entire
request to cancel.

Print errors when we fail copy log messages to the aggregation buffer

add unlang_timeout_section_push()

not overly tested, but the actual timeout handler only has minor
changes from the existing one.

hoist tmpls

if a tmpl is asked to parse %{...}. then the result is TMPL_TYPE_XLAT.

However, if the contents of that xlat are identically a tmpl, e.g.
User-Name, then there is no reason to keep the xlat.  Instead, we
hoist the tmpl we really want, and discard the intermediate xlat

this simplifies the internal data structures, and allows for
additional optimizations.  It also means that we do less work
at run-time in order to expand the tmpl.

print out that it's a tmpl

remove backticks from tests

And clean up corresponding use of exec module.  We hoist it to
unit_test_module.conf, and then replace any module-specific
configuration with a module-specific instant of exec

Use a function actually in libmruby to check for the library

More fixes for OpenSSL's questionable design decisions

Always drain the thread local error stack before calling SSL_read() and SSL_write() to prevent stale errors from masking SSL_ERROR_WANT_* return codes from SSL_get_error().

Add "ping" xlat for winbind, so we can run periodic checks against AD

Cache more things, and only unprotect the protected page

Fix timer use in rlm_sql_oracle

Setup custom fibre allocators for OpenSSL with a guard page

add "exceed_mtu" configuration flag for UDP sockets.

which defaults to "yes".

When set to "yes", clears the "don't fragment" bit in the IP
packet header.

When set to "no", it uses the OS definition for the DF bit.
Note that we do NOT set the DF bit.  OSX supports IP_DONTFRAG
only for raw sockets.  Linux always sets the DF flag for UDP
sockets.

No matter what this flag is set to, there are some situations
where UDP packets will silently disappear in the network.
When DF is set, "too large" packets might get an ICMP error
to the OS, which the server will currently ignore.
When DF is clear, "too large" packets might be silently discarded
by some other network element.

We can later add code to do actual PMTU discovery

move files to a better location

docs: Add v4 proxy information back into Antora from freeradius.org wiki

update handling of PMTU and EMSGSIZE

We disable PMTU discovery for the client code too, and not just
for the server code.

Add notes explaining what else needs to be done in order to fully
support PTMUD

update the write code to handle EMSGSIZE.  This should arguably
be done only for connected UDP sockets.

use correct RFC

rearrange code to be simpler

remove variable for xlat_func_bare_words

remove transitional settings for xlat_func_bare_words

minor cleanups to remove xlat_func_bare_words

and add name to node which previously didn't have it.  That
changed the test output (for the better), so we update it, too

remove -S xlat_func_bare_words=no from tests

Scheduled fuzzing: Update src/tests/fuzzer-corpus/der.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/cbor.tar

use the new xlat argument parser

handle non-string arguments to Perl xlat function

by the simple expedient of mangling them to a string

quote strings in module tests

set is_argv if the function will do it's own escaping

and update rlm_rest with the will_escape flag

add "will_escape" for xlat args, and have LDAP use it

rlm_ldap does it's own escaping, which is unusual

quote bare words in redis ippool tool tests

doc: import customer doc EAP Certs - updated links to relevant sections (HIVE 3404)

alloc call.args

add nonnull

to hopefully get more information about UBSAN issues in CI OSX

allow dict to be NULL when setting the function

if so, also set needs_resolving.

Because an xlat can be parsed from a module configuration, where
the dictionary is unknown.  Until such time as all of the modules
are converted to use call_env, this is likely the best approach.

mark safe_for recursively

now that we have strings as groups

move xalt func code into common routines

for less code duplication, along with other cleanups

turn checks into explict comparisons

otherwise in some uses, the checks won't match.

remove TMPL_TYPE_NULL

it was only used for =* and !*. Those have been updated to use
ANY on the RHS

clean up attr_filter and map_to_vp()

only attr_filter passes comparison operators to map_to_vp()
we should arguably forbid comparison operators, as allowing them
could break other modules.

Also disallow comparison operators in map_to_request, as nothing
uses them.

more cleanups for map_exec_to_vp

remove unused variable.  Note that it does NOT parse RHS strings
as pairs, for assignment to a LHS list.

no need to switch over LHS type when we know what it is

allow for suppression of structural attributes, too

and remove "compat" flag.  If the admin wants to suppress printing
of the Packet-Type attribute, they can list it in the suppress
block.

remove attr_protocol and attr_user_password

attr_protocol is now unused, and attr_user_password will be
replaced with better choices

move request->dict to proto_dict and local_dict

in order to split uses of base protocol dictionary, and
dictionary with local variables.

The protocol dictionary is used for encoding / decoding,
including xlats, and attributes read from external modules such as SQL or LDAP.

The local dictionary is used for local variables

it is saved, updated, and restored every time the interpreter
defines a local attribute

update request_init() to set dict to internal if it isn't passed
in.

update nearly all references to run-time parsing from request->dict
to request->local_dict.  Only the protocol encoders are left
unchanged.

this means that maps, %debug() etc. can now reference local
attributes, which they couldn't before.

update %eval() to use the local dict, too.

update fr_listen_t to have a dict, so the worker thread can use it.

and don't set request->dict in the listen decode any more.

remove references to request->dict

we can't change protocols when reading a request off of disk

remove unused assignment

there's no need for INPUT_ARGS

there's now only one type of function, as opposed to the
transitional MONO and INPUT_ARGS.  So we remove the redundant
field and update the associated checks

Ensure the GIL is locked before calling Py_XDECREF

Revert "We never manually incref on the module"

This reverts commit 798de18ec34c1ea49f2d5d6041f779c4760d41bd.

Actually we do need to do this

quiet static analyis

simplify setting of xlat flags

move more to common functions to avoid ad-hoc setting

move common code to tokenize word

print out more flags

move tokenize regex

from expr to tokenize_word, in preparation for moving more over

docs: added eap certificates to Introduction >> Best Practices >> EAP Certificates (customer doc import from salt)

correct error offsets for test.xlat

better errors

print which brace is missing ')' or '}'

double-check and fix error locations

Update xlat expression parser to avoid a bounce through tmpls

the expression parser now calls the xlat_tokenize_word().  That
function returns xlat groups for strings, and not tmpls.

Update the %cast() function to always create its arguments as groups.
This helps when "foo%{User-Name}" is now parsed as an xlat group,
and not as an xlat which is pointing to a tmpl

xlat_process_arg_list() now calls a separate function to escape
and stringify its output

Add "is_argv" flag to xlat_exp_head_t.  This tells the xlat eval
code to NOT concatenate strings, as the function argument parser
will do that, with escaping.

various cleanups in xlat_tokenize_word()

Hoist constant strings after calling xlat_tokenize_input().  This
code should arguably be moved to xlat_tokenize_input().

xlat_argv tests now also print strings with the enclosing quotes.

We never manually incref on the module

It's reference count is increased on creation and decreased as the
interpreter is freed - thus freeing the module.

We never incref on the pythonconf_dict

The reference count is increased when the dictionary is added to the
module, and automatically removed when the module is freed as the
interpreter is freed.

With m_size = -1, freeradius module doesn't clear up correctly

Each module instance is getting it's own copy of the module, whereas
m_size = -1 implies it is global and causes a crash on exit when there
are multiple interpreters.

Add libpython global option to enable verbose logs

For deep debugging of Python behaviour

ensure that the XLAT_BOX flags are always initialized

print error on parsing no input

and update error location to point to the correct character

minor cleanups

hoist more things in xlat_purify

so that we don't have unnecessary nodes hanging around

use xlat_tmpl_normalize() in more places

so that we don't have duplicate code

add and set is_argv flag to node->call.args

so that we can add spaces as necessary when printing, and
we can also handle arguments better for the soon to be coming
argument tokenization changes

better handle change xlat type

free tmpls, so that the caller doesn't have to do this.

If the tmpl is data, and the new type is XLAT_BOX, then re-initialize
the box from the tmpl data, before freeing the tmpl

remove bounce through tmpl code for %{...}

Instead, we create an XLAT_GROUP to hold the child xlat.

We then also create a "hoist" flag, which only exists for a
group node, and isn't in the flags.

update the debug printer to match.

Update the evaluation code to look for the "hoist' flag,
and then hoist the result instead of creating a value-box group.

Note that the result may be empty.  In which case nothing is
added to the output dcursor.  For xlat function arguments, this
highlights the need to have each argument expanded into its own
group.

more set / check flags for xlat expressions

verify that the arguments to functions are grouped correctly

use better safe_for value

check for errors after purify

clean up xlat_tokenize_word()

don't leak nodes, and don't set flags incorrectly

we don't allow unresolved xlats

it helps to return errors when there are error cases.

Disallow "foo." for list existence.  Arguably "foo.[*]" is better.
the xlat condition / expression parser already replaces a bare
existence check with a %exists() wrapper.  So the run-time code
doesn't need to expand the entire thing.

call stringify even if there's no escape

and mark safe_for depending on whether or not there's no escape

Scheduled fuzzing: Update src/tests/fuzzer-corpus/dhcpv6.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/radius.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/util.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/tftp.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/vmps.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/tacacs.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/dns.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/dhcpv4.tar

Scheduled fuzzing: Update src/tests/fuzzer-corpus/bfd.tar

force stringification of quoted strings for the old xlat evaluator.

when we see a value-box group, it is likely for a string which
has been converted to an XLAT_GROUP.  In that case, stringify it
before escaping it.

docs: update howto/Datastores/Active Directory install/configure instructions

Added 'frag errors' info to introduction/trouble-shooting/connectivity section

update nav bar

docs: Update howto/datastores/ad

docs: update howto/Datastores/Active Directory install/configure instructions.
Added 3 sub-sections - Integrating AD, Configuring ntlm, Installing winbind

we no longer need a macro for escape

rearrange the code so that the escaping is done first.

but we do assert that the value-boxes are not groups, in preparation
for updating the expression parser.  Those changes mean that a
string which contains an xlat expansion will result in a group
of the component pieces.  We can then escape each component piece
individually, before concatenating them into the resulting string.

initialize and print out constant flag

add tmpl normalization to xlat_tokenize_word()

add tmpl tokenize and triple quotes to xlat_tokenize_word

in preparation for calling it from xlat_tokenize_expression

move the expression parser back to tokenize_argv()

and hoist the parse rules for quoted text back, too.

This is in preparation for making xlat_tokenize_word() semi-public,
and calling it from xlat_tokenize_expression

minor float fixes

for numerical stability

add cast of float to time_delta

and it turns out that the cast-time_delta test was wrong.  Which
resulted in discovering that parsing time_delta decimals was wrong.

added "cast" function to unit_test_attribute.  Added tests for
casting to unit tests.

update cast-time_delta test to use correct values, and to do
delta comparisons for floating points

print out scale and raw values for time_delta

simplify parsing of time_delta

the old code parsed fractions incorrectly.  Rather than trying to
debug and fix it, we just change the code to parse floating point
numbers.