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.

typos and tweaks

concatenate function arguments when evaluating

the edit code already does this.  The function argument code
did not.  The result was that the functions were being passed
value-box lists / groups, when the intention of the admin was
to pass in one quoted string.

The xlat expression parser "fixed" this issue by adding a cast
when it parsed strings.  But that cast would then encapsulate the
function arguments into another function call.  That either
prevented the escaping of strings, or did the concatentation to
string which then mashed it to SAFE_FOR_NONE.

The final string would then be escaped, which is not what the
admin intended.

more quote arguments

quote function parameters which are bare words

ensure an empty string has a value

"%{1}" should result in an empty string if %{1} doesn't exist

strings may have embedded NULs

hoist tokenize bare word / string out of xlat_tokenize_argv

in preparation for calling it from xlat_tokenize_expression()

allow escape functions to return 1 for "I mashed safe_for already"

use strdup_shallow_replace here, too

and update json to say that literals in the config files are
safe for any.

don't mash safe_for if the function already did it

move to strdup_shallow_replace here, too

spelling fixes, and print out errors using RP...

use fr_value_box_strdup_shallow_replace

which is less work than the alternatives

remove unnecessary initialization

set default safe value for literals

remove debugging

quiet static analysis

Initialise to suppress complier warning

Cast to suppress compiler warning

Remove type from static definition

Causes "initializer element is not constant" error

We expect ldap.uri.escape to escape whatever it is given

Add fr_value_box_is_safe_for_only()

Where we need to specifically exclude SAFE_FOR_ANY - e.g. escaping
functions which may need to operate on literals

Exit quickly if there's nothing to do

pre and post proxy don't exist now

Use fr_value_box_strdup_shallow_replace for escaped value replacement

To avoid the box being re-initialised

Correct macro

move fr_value_box_escape_t to a structure

which can then contain the function, a safe_for value, and an
always_escape parameter.

we already have "len".  No need to call talloc array length

update montioring section - nave & copy/edit files

docs: customer doc import HIVE 3360/3361 Monitoring section - nav update, add new fileis (tools)

Updated nav and logging files

quiet analyzer

remove unused functions

in the interest of removing 'tainted', remove functions which
use 'tainted', but which aren't used anywhere.

allow parsing 192/8 and 192.0/16, etc.

fix the filename escape function to use the normal API

make sure that tainted boxes are marked as unsafe.

Add test for filename functions

print out literals_safe_for in tmpl_rules_debug

Return correctly after parsing error

Free test list

Test time_offset in rlm_totp

Add time_offset to rlm_totp

Comparable to using TOTP-Time-Offset in the control list in v3.2, but
using the v4 approach of allowing the attribute to be set.

Replace dictionary.rfc3825 with dictionary.rfc6225

RFC6225 obsoletes RFC3825

%map() returns bool, not int8

and isn't it really %eval(), but with assignment?

The normal %eval() evaluates conditions and expressions.

track safety of regex data

so that if we do regex captures of something which is SAFE_FOR_SQL,
the resulting string is also SAFE_FOR_SQL.

There are odd cases where this _might_ be wrong, such as when
the capture text crosses a quoted string boundary.  But that is
arguably the fault of the admin who created the offending regex,
and decided to use it in an unsafe manner.

return VOID is not NULL

this check also allows us to check that the function was
declared to return nothing, but actually returned something

remove "tainted" argument from fr_value_box_from_str()

either the value was set to false, OR the output "safe_for"
was set to an appropriate value.

copy value box safety thingies in more places

remove unused function

move concat functions to taking an output value-box

where the safe_for / tainted / secret flags are now stored.

This helps to get rid of "tainted", which is a good thing.
It moves multiple arguments to one.

It means that we can now track the safe_for value across
concatenation.  The previous code didn't track the safty
values across concatenation.

it helps to initialize the output value-box

allow debug level to be changed dynamically

%debug(4) didn't actually do anything, because it changed
request->log.lvl.  And the log_request() function didn't check
that.

Update the code to log the message if either the _entire_ request
is marked as "log at this level" or if this particular destination
is marked as "log at this level"

add and use fr_value_box_safety copy / merge

simplify %exists()

it should only be called internally, and shouldn't be called
bu admins.  So remove that functionality

typo

docs: Add howto/Datastore section & AD/LDAP/SQL/REDIS subsections.

he datastore/<type>.adoc files are stubs with headings only.

add and document regex.escape()

which always escapes the input

move regex escape rules to regex code

Add tests for nested timers

Disarm a list of timers

Check for parent not tl->parent

Passing a NULL pointer to fr_timer_disarm is a noop