ci: adds a build with make tags

configure: correctly display nss/nspr status

If autodiscovery of libnss was used (default), then the line
 libnss support:                          yes
was never set to no.

Same behavior for libnspr.

Broken by commit 'configure: fix nspr check logic' (7ea269a212a3a2209effc3cc9300873d6a06859e)

flow: cleanup expectations first

Make sure to cleanup expectations for a flow as the first step, before
parts of the flow itself are getting cleaned/freed.

Also indicate use unlikely as flows with expectations should be relatively
rare.

app-layer-expectation: update copyright date

app-layer-expectation: clean expectation at flow end

When a flow timeout, we can have still existing expectations that
are linked to this flow. Given that there is a delay between the
real ending of the flow and its destruction by Suricata, the
expectation should be already honored so we can assume the risk
to clean the expectations that have been triggered by the
to-be-deleted flow.

app-layer-expectation: limit number of expectations

This patch introduces a limitation in term of number of
expectations attached to one IPPair. This is done using
a circle list so we have a FIFO approach on expectation
handling.

Circleq list code is copied from BSD code like was pre existing code
in queue.h.

app-layer-expectation: remove unused parameter

tests/bsize: Fuzzing test case added

This commit adds a test case to validate the issue found during fuzz
testing.

detect/bsize: Ensure numeric values fit

This commit ensures that the numeric values will not exceed the size of
the containers used to hold them.

detect/parse: fix crash on 'internal' keyword use

When keyword __flowvar__postmatch__, an internal keyword, is used
in a rule the 'Setup' func ptr will be NULL. This caused a crash.

fuzz/siginit: fix leak in case of bidir sig

fuzz/siginit: minor improvements

Enable detect engine 'quiet' mode to generate less output.

Set a fake filename so that datarep doesn't hit a reachable assert.

detect/pkt_data: error on unconsumed transforms

If a rule has transforms w/o consuming them (e.g. a content keyword),
don't consider 'pkt_data' valid.

detect/pkt_data: code and test cleanup

detect: more robust against transform issues

In case of transform issues (transform not consumed before pkt_data
for example), the code would hit an ugly BUG_ON.

Address this by a more graceful error message, that will still
invalidate the sig but not crash the engine.

rfb: make sure size calculations do not overflow

Addresses #3570 by extra checking of calculated size requests.

With the given input, the parser eventually arrived at
parser::parse_failure_reason() which parsed from the remaining four
bytes (describing the string length) that the failure string to follow
would be 4294967295 bytes long. While calculating the total size of the
data to request via AppLayerResult::incomplete(), adding the four bytes
for the parsed but not consumed string length caused the u32 length to
overflow, resulting in a much smaller value triggering the bug condition.

This problem was addressed by more careful checking of values in each step
that could overflow: one subtraction, one addition (which could overflow
the usize length values), and a final check to determine whether the result
still fit into the u32 values required by AppLayerResult::incomplete().
If so, we would safely convert the values and pass them to the result type.
If not, we simply return AppLayerResult::err() but do not erroneously and
silently request the wrong amount.

detect/tls: Use pcre_copy_substring to avoid leak

This commit eliminates a memory leak while parsing TLS version
information. The leak was identified through fuzzing.

build: wrap fuzz targets in guard to fix 'make tags'

fuzz/sigpcap: fix FPs due to missing pkt cleanup

decode/vxlan: minor yaml example clarrification

decode/teredo: implement port support

Implement support for limiting Teredo detection and decoding to specific
UDP ports, with 3544 as the default.

If no ports are specified, the old behaviour of detecting/decoding on any
port is still in place. This can also be forced by specifying 'any' as the
port setting.

Use StringParse* for all parsers and configurations

Use appropriate ByteExtractString* functions

util: Add StringParse* functions

StringParse* functions would perform a stricter check compared to
ByteExtractString* functions. These new functions shall also check if
any extra characters follow the extracted numeric value in addition to
the checks performed by ByteExtractString* and return -1 in that case.
This is particularly important in parser, configuration and setup functions.

fuzz: remove obsolete AFL code

ci: add fuzztargets and afl build test

fuzz: simpler way to force usage of CXX linker

fuzz: remove decodeder fuzz target

As we removed decodeder function

configure: right test for AFLFUZZ_PERSISTANT_MODE

ci: enables fuzz targets in one build

github workflow wih debian

stream/tcp: fix STREAM_HAS_SEEN_DATA macro

The macro would not return true for smaller TCP streams, leading to
cases where the app-layer was not notified of EOF.

stream/tcp: clean up stream flags

rust/x509: map decoding errors to decoder events

ssl/tls: call rs_cstring_free for strings allocated in Rust

rust/x509: use the raw serial number so leading zeros are not removed

DER: remove the C parser for DER

ssl/tls: use the rust decoder to decode X.509 certificates

rust: add common function to exchange CString objects from/to C

detect: byte-test convert neg_op flag to a bool

Only 8 flags are permitted so convert one of them to a struct member. I
choose neg_op

detect: Add unittests to exercise bitmask

detect: fixup incorrect comments, indentation

detect: byte_test impl for bitmask

This commit implements byte_test's bitmask feature.

doc: fix documentation typos

doc: Update byte_test documentation

rfb: use more idiomatic Rust code

Using 'if let Some()...' makes the code in these many checks more
concise and readable.

stream/tcp: fix fast open off by one

With data on SYN the sequence number used for the first data
was off by one, leading to the next segments to appear to come
after a one byte gap.

fuzz: check tcp splitting evasions in protocol detection

fuzz: enable AFLFUZZ_PERSISTANT_MODE for libfuzzer targets

fuzz: use env variable to restrict app layer

fuzz: adds eight fuzz targets

And ways to compile them with enable-fuzztargets at configure time
Adds utility function in util-unittest-helper

add RFB parser

This commit adds support for the Remote Framebuffer Protocol (RFB) as
used, for example, by various VNC implementations. It targets the
official versions 3.3, 3.7 and 3.8 of the protocol and provides logging
for the RFB handshake communication for now. Logged events include
endpoint versions, details of the security (i.e. authentication)
exchange as well as metadata about the image transfer parameters.
Detection is enabled using keywords for:

 - rfb.name: Session name as sticky buffer
 - rfb.sectype: Security type, e.g. VNC-style challenge-response
 - rfb.secresult: Result of the security exchange, e.g. OK, FAIL, ...

The latter could be used, for example, to detect brute-force attempts
on open VNC servers, while the name could be used to map unwanted VNC
sessions to the desktop owners or machines.

We also ship example EVE-JSON output and keyword docs as part of the
Sphinx source for Suricata's RTD documentation.

output/anomaly: minor code cleanups

detect/app-layer-event: code cleanups

detect/pcre: Correct spelling typos

general: copyright bump

detect: Update to take advantage of PCRE refactor

This commit changes the keyword detectors to use the refactored PCRE
modifications from detect-parse.[ch]

detect/pcre: Changes to support pcre_jit_exec

This command causes `pcre_jit_exec` to be used when available. If it's
available and there are allocation errors preparing for it, things
fallback to `pcre_exec`.

detect/pcre: Add warning for failed registrations

This commit adds a warning used by the PCRE detect logic when it fails
to register initialization and free functions for per-thread JIT stack
handling.

This error code is only used when the platform has PCRE JIT exec
functionality.

detect/parse: Refactor interfaces/definitions

This commit refactors existing code patterns to reduce code duplication
and to be a base for supporting additional PCRE jit-related actions.

configure: Determine whether pcre_jit_exec exists

This commit adds logic to determine whether pcre_jit_exec is present in
the system's pcre library using AC_RUN_ELSEIF

devguide: document new app-layer retvals

doc: adds doc for ipv4.hdr signature keyword

detect: adds icmpv6.mtu keyword

detect: adds utility file for uint keywords

detect: define generic PrefilterIsPrefilterableById

detect: extend PrefilterPacketHeaderValue to 16 bytes

decode: fix endianness for ICMPv6 MTU

doc: fix typo in DetectTcpmssSetup description

And use lowercase true for boolean

stream: fix direction flags in corner case

When a TCP DNS flow would start with a GAP on the TS side, the successful
protocol detection on the TC side would trigger 'opposing side' reassembly
and app-layer processing. In this case the stream flags would indicate the
wrong direction and the wrong parser would be called.

app-layer: minor code cleanup

app-layer: fix progress tracking

Esp in combination with GAPs and proto detection.

app-layer: extend AppLayerResult to add convenience

rust: merge parser.rs into applayer.rs

Both were serving the same purpose.

app-layer: document return macros

nfs: switch to new 'incomplete' logic

Remove buffering code in favor of using incomplete API.

nfs: switch to AppLayerResult

smb: update return type of GAP handling

smb: convert to return AppLayerResult

Support returning 'incomplete' and remove the buffering
code from the parser.

app-layer: add 'incomplete' return logic

Allow app-layer parsers to indicate how much data they need
before being called again.

app-layer: update API to return more details

Add AppLayerResult struct as the Parser return type in
preparation of allowing returning 'Incomplete(size)' similar
to what nom in Rust allows.

app-layer: change return codes

This patch simplifies the return codes app-layer parsers use,
in preparation of a patch set for overhauling the return type.

Introduce two macros:

APP_LAYER_OK (value 0)
APP_LAYER_ERROR (value -1)

Update all parsers to use this.

app-layer: minor optimization

stream: fix function style

ftp: minor code cleanups

nfs: code cleanups

Use 'if let' to replace simple 'match' statements.

Use explicit returns to easy code review.

smb: fix rustc 1.42 warnings

config: General typo and grammar cleanup

docs/napatech: Correct typo

python: style for prscript

Remove unnecessary pass
Remove unused variable

python: style for suricatasc.py

Remove unnecessary return
Better comparison with None

python: remove unused imports

dag: Skip over ERF_TYPE_META records

Suricata generates an error on unrecognised ERF types.
Suricata should ignore ERF 'Provenance' records with ERF_TYPE_META.

suricata.yaml/dns: removed unused settings

Remove DNS settings global-memcap, state-memcap and request-flood.
These have never been used in the Rust implementation of the DNS
decoder.

detect/parse: allow for OK signature parsing errors

The idea of an OK signature parsing error is an error that is
allowed to occur, but still lets test mode pass, unlike
silent errors which will still fail testing.

This is introduced to allow for app-layer event keywords to be
removed, but not have old rules fail out on this case. For example
the Rust DNS parser removes from DNS app-layer events that are
not used anymore.

To signal that an error is OK, -3 is returned. This also implies
silent.

detect/parse: softer error on unknown app-layer event

On an unknown app-layer event, return -3 for "silent OK fail". A
warning will still be emitted, but its not considered a rule parse
error. This is to handle app-layer events being removed in a more
graceful manner for the user.

This allows -T to pass with an old app-layer events rule file
that may used removed app-layer event keywords.

dhcp: remove C app-layer-dhcp wrapper

This just wrapped the Rust function to register the parse,
so instead just call the Rust function directly to remove
the C wrapper, and the 2 C files.

dns: register parsers from Rust

And port the C DNS tests to Rust.

dns: remove C wrapper functions to Rust

Remove registration of C wrapper functions and register
the Rust functions directly for UDP.

dns: cleanup: move event callbacks into Rust

Remove app-layer-dns-common.c as its no longer needed.

dns: cleanup: remove unused events

Removed events that are no longer used since the Rust
implementation of DNS:
- UnsolicitedResponse
- StateMemCapReached
- Flooded