fuzz/pcap: add missing flow queue

fuzz/pcap: enable http2

version: continue 6 development

version: update to 6.0.0-beta1

changelog: update for 6.0.0-beta1

plugins: remove unused func, suppressing compile warning

plugins: add missing guards

detect/http2: fix header inspection

Header inspection was overwriting data that was still being
referenced by the detect engine, leading to ASAN issues.

output/ssh: Use correct file context

This commit corrects an issue with the SSH output module that resulted
in a SEGV when SSH output is logged.

plugins: support for capture plugins

Allow a plugin to register itself as a capture source. This isn't that
much different than how current sources register, it just happens
a little later on during startup.

One "slot" is reserved for capture plugins, but multiple plugins
implementing a capture can be loaded.  The --capture-plugin command
line option must be used to tell Suricata which plugin
to use.

This is still very much a work in progress, but can load
PF_RING as a capture plugin.

plugins: initial support for a filetype plugin

A filetype plugin is a plugin that implements an eve filetype. Most
of the current filetypes could likely be implemented as such a plugin.
Such a plugin must implement Open, Close and Write, where Write
is provided the formatted JSON to be logged.

This commit also includes the plumbing for plugin loading. Example
plugin to come.

Plugins are loaded by the "plugin" section in the configuration
file:

  plugins:
    - /path/to/directory/plugins
    - /path/to/plugin_file.so

This can also be done on the command line with:

  --set plugins.0=/path/plugin_file.so

util-error: define generic plugin error code

configure: check for plugin support

Currently plugin support requires the dlfcn.h header
file and compiler support for -rdynamic.

plugins: config.h: move into src and rename to autoconf.h

While fixing files that include config.h, just remove the
include if possible.

http2: log as http to abstract http and http2 a little

This commit logs http2 as an http event. The idea is to somewhat
normalize http/http2 so common info can be version agnostic.

This puts the http2 specific fields in an "http2" object inside
the "http" object.

HTTP2 headers/values that are in common with HTTP1 are logged
under the "http" object to be compatible with HTTP1 logging.

http2: log headers in the same format as http (1)

Log the headers in request_headers, and response_headers like
http1 to remain compatible.

suricata.yaml: mark http2 as experimental

Make it clear that HTTP2 is experimental and disabled by default.

http2: initial support

http2: adds documentation

detect: generic structures for mpm with lists

flow/spare: implement pool shrinking

Remove at most one block per run, so it shrinks slowly.

flow: redesign of flow timeout handling

Goals:
- reduce locking
- take advantage of 'hot' caches
- better locality

Locking reduction

New flow spare pool. The global pool is implmented as a list of blocks,
where each block has a 100 spare flows. Worker threads fetch a block at
a time, storing the block in the local thread storage.

Flow Recycler now returns flows to the pool is blocks as well.

Flow Recycler fetches all flows to be processed in one step instead of
one at a time.

Cache 'hot'ness

Worker threads now check the timeout of flows they evaluate during lookup.
The worker will have to read the flow into cache anyway, so the added
overhead of checking the timeout value is minimal. When a flow is considered
timed out, one of 2 things happens:

- if the flow is 'owned' by the thread it is handled locally. Handling means
  checking if the flow needs 'timeout' work.

- otherwise, the flow is added to a special 'evicted' list in the flow
  bucket where it will be picked up by the flow manager.

Flow Manager timing

By default the flow manager now tries to do passes of the flow hash in
smaller steps, where the goal is to do full pass in 8 x the lowest timeout
value it has to enforce. So if the lowest timeout value is 30s, a full pass
will take 4 minutes. The goal here is to reduce locking overhead and not
get in the way of the workers.

In emergency mode each pass is full, and lower timeouts are used.

Timing of the flow manager is also no longer relying on pthread condition
variables, as these generally cause waking up much quicker than the desired
timout. Instead a simple (u)sleep loop is used.

Both changes reduce the number of hash passes a lot.

Emergency behavior

In emergency mode there a number of changes to the workers. In this scenario
the flow memcap is fully used up and it is unavoidable that some flows won't
be tracked.

1. flow spare pool fetches are reduced to once a second. This avoids locking
   overhead, while the chance of success was very low.

2. getting an active flow directly from the hash skips flows that had very
   recent activity to avoid the scenario where all flows get only into the
   NEW state before getting reused. Rather allow some to have a chance of
   completing.

3. TCP packets that are not SYN packets will not get a used flow, unless
   stream.midstream is enabled. The goal here is again to avoid evicting
   active flows unnecessarily.

Better Localily

Flow Manager injects flows into the worker threads now, instead of one or
two packets. Advantage of this is that the worker threads can get packets
from their local packet pools, avoiding constant overhead of packets returning
to 'foreign' pools.

Counters

A lot of flow counters have been added and some have been renamed.

Overall the worker threads increment 'flow.wrk.*' counters, while the flow
manager increments 'flow.mgr.*'.

Additionally, none of the counters are snapshots anymore, they all increment
over time. The flow.memuse and flow.spare counters are exceptions.

Misc

FlowQueue has been split into a FlowQueuePrivate (unlocked) and FlowQueue.
Flow no longer has 'prev' pointers and used a unified 'next' pointer for
both hash and queue use.

unittests: check for flow memuse

flow-manager: call other timeouts max once a second

Call Defrag and others only once per second. Flow Manager may wake
up (much) more often when flow engine is under resource pressure.
As this does not affect Defrag and others, it only unnecessarily
adds load.

flow-manager: only update FlowBucket::next_ts if it changed

flow: unref flow at end of flow worker

flow: do timeout checks before tuple compare

flow: don't reorder list on lookup

Reduces cache misses.

flow: timeout check on flow lookup

flow: simplify hash lookup logic

Remove double compare paths in favor of a single unified path.

flow: only move lastts forward

Pcaps with timestamps jumping around could confuse flow timeout
handling otherwise.

flow/worker: check pkt src using DEBUG_VALIDATE_BUG_ON

rust/rdp: Fix use of incorrect buffer

This commit updates the connection confirmation parsing function to use
the correct buffer when determining the packet type.

smb: use uuid crate

rust: only run cbindgen if needed

Only run cbindgen when necessary. This is a bit tricky. When
building a dist we want to unconditionally build the headers.

When going through a "make; sudo make install" type process,
cbindgen should not be run as the headers already exist, are
valid, and the environment under sudo is more often than
not suitable to pick up the Rust toolchains when installed
with rustup.

For the normal "make" case we have the gen/rust-bindings.h file
depend on library file, this will cause it to only be rebuilt
if the code was modified.

For "make dist" we unconditionally create "dist/rust-bindings.h".
This means the generated file could be in 2 locations, so update
configure.ac, and the library search find to find it.

The "gen/rust-bindings.h" should be picked up first if it exists,
for those who develop from a dist archive where "dist/rust-bindings.h"
also exists.

Not completely happy having the same file in 2 locations, but not
sure how else to get the dependency tracking correct.

alert/eve: add snmp metadata for rdp alerts

Redmine issue:
https://redmine.openinfosecfoundation.org/issues/3441

alert/eve: add snmp metadata for snmp alerts

Redmine issue:
https://redmine.openinfosecfoundation.org/issues/3441

dcerpc: handle gap for TCP streams

dns: add tailing data to split tcp unit test

Add trailing data to the complete payload to test the case
where data is consumed, but still incomplete.

dns: fix subtraction overflow in debug message

The math for the return value wasn't updated in the debug log
to match the logic and could lead to a subtraction overflow

dns: return status from parsing tcp request

dns: fix incomplete results

and messages parsing whose length is >= 32768

pcap: recusively reading pcaps / documentation

Changes to doc/userguide/partials/options.rst for feature 2363
   (reading pcaps recursively)

pcap: read directories recursively

Describe Changes
- Added ability to recursively read pcap directories
- src/suricata.c: addition of new command line parameter
    --pcap-file-recursive
- src/source-pcap-file.c: parsing of the command line argument
- src/source-pcap-file-directory-helper.h: two thread vars tracking
    directory depth and should recurse
- src/util-error.c / src/util-error.h:
   Added new warning code "SC_WARN_PATH_READ_ERROR"
- Redmine ticket: https://redmine.openinfosecfoundation.org/issues/2363

Ticket: #2363

path: introduce path handling util funcs

This commit provides changes to util-path.c and util-path.h
to support the recursive reading of directories. It adds
4 functions.
- SCIsRegularFile to provide OS independent file info.
- SCIsRegularDirectory to provide OS independent directory info.
- SCRealPath is an OS independent wrapper for realpath.
- PathJoin to manage path resolution logic.

stream/app-layer: break loop on proto change

datasets: fix null pointer deref

datasets: Init even in socket mode

Closes redmine ticket 3476.

detect-mqtt: unify error handling in rule parsing

This is meant to provide a single path to the error case.
This might help make things more clear for static
checkers.

detect-engine: initialize struct fields

http: merge duplicated code

HtpRequestBodyHandlePUT and HtpRequestBodyHandlePOST

http: use more precise parameter in HtpRequestBodySetupMultipart

So that we can see that it does not have to handle gaps

http: remove unused code

HtpRequestBodySetupPUT function
So that we can see that we do not use data=NULL in there

file: handles gaps natively

ie data=NULL and len>0 parameters

util: PrintRawDataFp handles null

for gaps which are data=NULL and len>0

files: rust closes files even on 0 length chunk

applayer: allow rust parsers to have only one probe

output-json: add MAC address output

This commit adds MAC address output to the EVE-JSON format. We follow the
remarks made in Redmine ticket #962: for packets, log MAC src/dst as a
scalar field in EVE; for flows, log MAC src/dst as lists in EVE. Field names
are different between flow and packet context to avoid type confusion
(src_mac vs. src_macs). Configuration approach and JSON representation is
taken from previous GitHub PR #2700.

output/anomaly: Restrict anomaly logger count

This commit restricts the anomaly logger count. The restriction is
necessary due to state maintenance in the logger that doesn't scale
beyond a single logger.

Until that issue's solved, when multiple anomaly loggers are configured,
an error message will be emitted to highlight the restriction.

signature: checks for integer overflow in limits propagation

eve/yaml: move mqtt down

fuzz/pcap: enable MQTT parser

datasets: reload static sets

rust/mqtt: add MQTT parser

detect: adds engine for u8 keywords

doc/output: Document multithreaded eve option

output/json: Multi-threaded EVE logging support

This commit modifies the JSON loggers with changes necessary to support
multi-threaded EVE output.

Each "thread-init" function sets up the per-thread log file context for
subsequent calls to the JSON output to buffer function.

log: Support multi-threaded eve output.

output: Check for fwrite_unlocked

This commit creates a macro for fwrite_unlocked which is probed during
configuration time.

output: Correct typos

output: Remove unused variables/define

log: remove unused include files

output/flow: Eliminate unnecessary parameter

This commit removes a parameter to an internal-only function call.
Removing the parameter allows an JSON builder optimization to be used.

output/netflow: Eliminate unneeded parameter

This commit changes an internal-only function to remove a parameter
that's invariant in all use cases. This allows an JSON builder
optimization to be used.

transform: adds url_decode keyword

Fixes https://redmine.openinfosecfoundation.org/issues/2689

Adds a new source file to handle this keyword.
And modifies documentation, Makefile, and registration accordingly.

url_decode decodes url-encoded data, ie replacing '+' with space
and '%HH' with its value.

stream: fix endless loop in traffic with gaps

flow: avoid double state update on reuse

Avoids an unnecessary atomic operation.

flow: minor cleanups

flow: validate emergency timeout settings

Make sure they are below the regular values.

flow: improve performance in emergency mode

When the flow engine enters emergency mode, 3 things happen:

1. a different set of (lower) timeout values are applied
2. the flow manager runs more often
3. worker threads go get a flow directly from the hash table

Testing showed that performance went down significantly due to concurrency
issues:

1. worker threads would fight each other over the hash access
2. flow manager would get in the way of workers

This patch changes the behavior in 2 ways:

1. it makes the flow manager slightly less aggressive. It will still
   try to run ~3 times per second, but no longer 10 times.

   This should be reducing the contention. At the same time flows
   won't time out faster if they are checked many times per second.

2. The 'get a used flow' logic optimizes the use of atomics by only
   doing an atomic operation once, and while doing so reserving
   a slice of the hash per worker.

   The worker will also give up much quicker, to avoid the overhead
   of hash walking and taking and releasing locks.

These combined changes show much better 'under stress' behavior, esp
on multi-NUMA systems.

enip: use status for probing parser

signature: checks for integer overflow in limits propagation

detect: fix read overflow in DetectGetLastSMByListId

eve: remove unused jansson code

eve/metadata: create preformatted json string at start up

Avoid runtime overhead of assembling metadata json string by
pre-creating it at rule parsing time.

detect/profile: convert match dumps to jsonbuilder

Remove unused code and do minor misc cleanups as well.

pfring: fix compile warning

eve: remove unused json_t common functions

These are no longer used as all callers have switched to
the JsonBuilder equivalents.

eve/tls: minor cleanups

eve/metadata: convert to jsonbuilder

stream: call parser with 0 data on EOF

This way both sides can call the EOF logic.

app-layer/tcp: don't use un-ACK'd data

Still use un-ACK'd data in unclean shutdown. This means any state
before TCP_CLOSED, or TCP_CLOSED that was caused by a RST.

flow/timeout: flag last pseudo packet

Flag the last flow timeout pseudo packet so that we can force
TX logging w/o setting both app-layer flags.

Case this fixes:

1. flow times out when only TS TCP data received, but non of it is ACK'd.
   So there is no app-layer proto yet, or app state or Flow::alparser. So
   EOF flags can't be set.

2. Flow timeout sees no reason to create pseudo packet in TC direction.

3. TS pseudo packet finds HTTP, creates HTTP state, flag EOF TS.

4. TX logging skips HTTP logging because:
   - TC progress not reached
   - EOF TC flag not set.

The solution has been to flag the very last packet for the flow as such
and use it has a master-EOF flag.

stream/tcp: track if ssn has been closed with RST

app-layer: set EOFs on app-layer disable

flow/worker: set EOF flags on change proto

flow-timeout: set app-layer EOF flag

app-layer: add debug

stream: minor debug fixup

app-layer/pd: improve size check in bail conditions