ensure that groups have a ref extension

refs can't be NULL

the underlying "da" may have already been freed

if it was re-written

make error message clearer

Require '.' or '@' in references

which ends up being a lot clearer than

DEFINE foo bar clone=foo

where the DEFINE is in a child context via BEGIN/END, and the
'clone' ref is in the root context

Update all of the dictionaries to match.

As a bonus, dict_protocol_reference() can now distinguish the
cases of "error" from "reference not found"

Update the antora documentation to match.  Create a new
reference page which contains all of the documentation for
references.

add fr_sbuff_eof(), which is easy to remember

add and use "has_fixup" flag.

When we copy an attribute, we need to check if it has pending
fixups.  If so, we can't copy it.  This gives the admin a
descriptive error, rather than having something go wrong later.

This situation happens when we're cloning an attribute that has
children, and those children have fixups.

A more in-depth fix would be to move the fixup lists to the
fr_dict_t.  The cloned attribute could then add itself to a
separate "clone after fixups" list.  So the clone could be applied
last, after all of the fixups have been applied.

Part of the fix is checking for pending fixups and complaining.
More of the fix is setting "ref=..." immediately, if it can be
resolved.  That way we avoid many pending fixups.

typo

ensure oid_and_value references OID-Tree

ensure that attribute references exist

only leaf types can have values defined

double-check more corner cases

and update dicts to match.

add more OIDs and update the tests

note for more corner cases to fix

decode unknown children, instead of erroring out

rename variable

it's the current attribute which is malformed and should be raw,
not the parent one

add qualifier && cpsuri, and update the tests

allow raw.1 = { ...}

define and use issuerAltName

check return code

is_oid_leaf is only for parent DER type 'sequence'

set and enforce minimum sizes

for a number of dictinary attributes

add 'size=MIN..MAX' and check it in more places

check for more corner cases on decoding

the tag should be what we expect, or at least be compatible with
what we expect.

On decoding set / sequence, ensure that we mark all input data
as consumed, even if we run out of children to decode.  That
way the decoder can move to the next DER item, instead of starting
to decode the next item from inside of the set / sequence.

In other words, we don't want the decoder wandering up and down
the eastern seaboard for three days, looking for Vancouver.

more MACRO_RETURN

narrow down string format dicts and tests

For now, we test encoding and decoding of strings by types.

Move conflicting tests to an "ignore" file.  Those tests define
the dictionary attribute as one DER type, and then do test
encode / decode as a different DER type

add tag compatible function

some attributes can be encoded in multiple ways, but will all
decode to the same FreeRADIUS data type.  Adding a function
allows us to be more flexible about the input data.

print out name instead of raw numbers

check max for allowed values, and set default if it's not set

sequence and set can never be structs

the FreeRADIUS type 'struct' is reserved for bit-packed fields.

reasons are bitstring

remove "is_choice"

iit's not used.  The dictionaries instead use type "choice", or
"sequence_of=choice"

other integer types aren't valid

move more run-time checks to asserts

the dictionary parser / validator already checks these things

move clean.coverage to coverage.mk

move validation checks from run-time to load-time

and tighten them up a little bit

tweak error checks and messages

consistently use program name

so that we don't have hard-coded "radiusd.conf" everywhere

Return reply packet type, not rcode

FAQ rework (33 questions) & troubleshooting guide (1st draft).
Build error fix - Concepts index xref resolved.

Updated faq, troubleshooting, added pages. Updated top-level nav file to include new entries.

Partials work for single-source publishing

remove more "&"

just use fr_dbuff_used().  CID #1642920

quiet coveritry re: bit shift.  CID #1642926

check return CID #1642924

limit tag value. CID #1642922

move to common file

now that we support loading the same dictionary from multiple
places

set max at load time rather than run-time

check return code.  CID #1642917, CID #1642918, CID #1642927

check return code.  CID #1642921

check for len==0.  CID #1642919

allow dictionaries to be used from multiple _different_ locations

In some cases we can't "clone" attributes.  So instead we allow
two different source locations to load the same dictionary

remove is_pair

now that we have sequence_of=oid_and_value

move run-time check to load check

add copyright and license

allow sequence_of=oid_and_value

and set_of=oid_and_value

which is a bit clear than 'is_pair'

protocol files depend on the test dictionaries, too

hoist more things during xlat_purify

add note about future improvements

do a better job of purifying xlats

set the can_purify flag in more places, add tests, and do
associated cleanups

remove is_pairs and other cleanup

Also, cut some variables which weren't being used when sorting
set items (reducing code).

Fixed a test case which should not have failed, and changed it
to test an actual failing case.

add migration flag which helps us get rid of "&"

if the flag is set, and the server is passed -C, it will complain
when the callenv config / etc. uses "&"

CALL_ENV_FLAG_ATTRIBUTE also means concat

because we don't parsr multiple _different_ attributes from one
expansion

remove more "&"

remove more '&'

remove '&'

remove '&'

quiet coverity.   CID #1642987

further limit OID encoding

due to rules of first 2 fields are (x*40) + y, if the first
component is 0 or 1, then the second component has to be 0..39

If the first component is 2, then the second component can be
anything.

clean up decode OID.

Remove & from policy files

simplify encode OID and catch parse errors

so that when the OID string is not an OID string, it fails
rather than encoding "something"

move the basic type encoding to its own file

so that we test encoding of all of the data types before we
start testing more complex things.

Add "count" to all of the inputs, too

use DER names in dictionaries

and forbid more FreeRADIUS types earlier in the parsing process,
with better error messages.

convert to more standard DER names

use more descriptive error messages

add comments

do load-time checks, not run-time checks

if the run-time code assumes that "is_pair" is only for type
group, then enforce that when we load the dictionaries.

rearrange to make name and parent available to validation routines

so that the type / flag validation routines have more information
with which to make their decisions.

remove 'option=' where it can be determined automatically

set the attribute number before checking the type and flags

so that the validation functions can double-check the attribute
number.

update error messages with more information

let's use lowercase names for consistency

try to allow just 'option'

In many cases, DER defines something like

ATTRIBUTE foo 1 type option=1

this seems redundant.

We make provisions for allowing just 'option', which could then
take the option number from the attribute number.

However, the function dict_read_process_attribute() initializes
the attribute number _after_ processing the flags / type field.

Once that code has been tweaked to parse the attribute number
first, this new DER code will work.  At that point, the DER
dictionaries can be updated with the following Perl script:

perl -p -i -e 'next if !/^ATTR/;s/option=\d+/option/' share/dictionary/der/dictionary*

batten down the hatches a little more.

things which need values should really take the values

remove 'tagnum=' for flags.

it was being used as a synonym for 'option=', and was therefore
not needed.

also remove 'class=', though it's just commented out.
The only uses of it were at the same time as setting 'option=',
and the option parser already sets the class

limit 'der_type=foo' to compatible FreeRADIUS data types.

Except for serialNumber, which is der_type=integer, and FreeRADIUS
type 'octets'.  That's because the serial numbers are larger than
64 bits, and we really don't need to see them as decimal values.

Update the decoder to allow this case.  The encoder already
allowed it, so we update the encoder with a comment explaining
why it's allowed.

more cross-checks and error messages

use consistent uint64_t for max

don't use uint64_t for 8-bit tags

which also cleans up a lot of uses of PRIu64

more UINT8_MAX cleanups

lower FR_DER_TAG_MAX

there's no reason to make it UINT8_MAX, as we only support a
small number of tags.

Also update the arrays to use

array[FR_DER_TAG_MAX] = { ... }

instead of

array[] = { ..., [TAG_MAX] = false }

be more stringent on allowed values

don't check just the first character.

Only allow tag values which we can encode and decode

perhaps save a bit of space using single bits for booleans

minor cleanups

no need to say it's a tag "num".

it's an enum, and that's good enough

remove unused array

and make other array static

we know this can never fail

rework encode_len() to be even simpler

and add comments which explain the functionality

check return.  CID #1642925