rust: derive crate: for custom derives

Currently has one derive, AppLayerEvent to be used like:

  #[derive(AppLayerEvent)]
  pub enum DNSEvent {
      MalformedData,
      NotRequest,
      NotResponse,
      ZFlagSet,
  }

Code will be generated to:
- Convert enum to a c type string
- Convert string to enum variant
- Convert id to enum variant

rust/applayer: define AppLayerEvent trait

The derive macro will implement this trait for app-layer
event enums.

macset: adjust test to pass after fix

ci: dummy git configuration for rebase

macset: fix memory size check

flow: be sure to check hash till the end

flow: add comment on flow handling

stream: increase memcap on memory errors

util/streaming: improve error handling

It differentiates memory error than regular ones.

flow: fix a debug assert

As the FlowBypassedTimeout function is interacting with the capture
method it is possible that the return changes between the call that
did trigger the timeout and the actual state (ie if packets arrive
in between the two calls). So we should not use the call to
FlowBypassedTimeout in the assert.

flow: document FlowBypassedTimeout

Main point is to document it is interacting with the capture
layer.

flow: more accurate flow counters

Don't increment the flow timeout counter for flows that are not
really timeout (as use_cnt is non zero). And also don't take into
account bypassed flows in the counter for flow timeout in use.

flow/worker: handle timeout edge case

In the flow worker timeout path it is assumed that we can hand off
flows to the recycler after processing, implying that `Flow::use_cnt` is 0.
However, there was a case where this assumption was incorrect.

When during flow timeout handling the last processed data would trigger a
protocol upgrade, two additional pseudo packets would be created that were
then pushed all the way through the engine packet paths. This would mean
they both took a flow reference and would hold that until after the flow
was handed off to the recycler. Thread safety implementation would make
sure this didn't lead to crashes.

This patch handles this case returning these packets to the pool from
the timeout handling.

flow/worker: set proper end flag

flow/manager: set proper end flag

detect: debug validation for list ids overflows

detect: move init only array to init data

detect/analyzer: use rule style pretty print for patterns

detect/content: generalize pattern pretty printing

detect/profile: add support for tx inspection

Add 'inspect_type' "packet" and "tx" for the two record types. Add more metadata
when available.

detect/analyze: dump patterns facility

Dump all patterns to `patterns.json`, with the pattern, a total count (`cnt`),
count of how many times this pattern is the mpm (`mpm`) and some of the flags.

Patterns are listed per buffer. So payload, http_uri, etc.

detect/content: add some more dsize tests

detect/dsize: set depth flag when applying dsize as depth

detect/analyzer: count mpm with depth, endswith

detect/analyzer: show payload separately in group dumping

detect/analyzer: add icmp to rule group output

detect/analyzer: display per rule prefilter details

detect/analyzer: count prefilter per rule group

detect/analyzer: add per rule mpm block to rules.json

detect/analyzer: support buffer names in sgh dump

flow: determine packet direction once per packet

decode: convert 'action' macros to inline funcs

Make sure most common branch is handled first to assist branch
prediction.

Macros still play a small role to please our 'action' cocci check.

detect/mpm: turn factory array into list

detect/stream: don't run mpm on packet if stream is available

doc: escape dot in pcre

unix-socket: Avoid spurious logs on close

Avoid spurious logs when suricatasc closes connection.

Use SCLogDebug for control connection EOF, and SCLogError for an error.

As Chandan Chowdhury described in redmine 3685. This makes the logging
consistent with the older `if (client->version <= UNIX_PROTO_V1)` block
about 20 lines above, and avoids polluting the logs with
`Unix socket: lost connection with client`.

ci: rebase specified s-v pr

So that CI does not fail, if suricata PR got upgraded in a new
version, but S-V PR did not get upgraded, and S-V changed
in master

dnp3: regenerate object decoding code

Ticket: #4558
So as to avoid intra-structure overflow

dnp3: adds bounds check for prefix chararray

Ticket: #4558
Avoids intra structure overflow

dnp3: use base64 macro in gen script

As is done already in C
cf commit ea0936199d142fc52ec69baf7984cbdd92dd4705

threading: don't pass locked flow between threads

Previously the flow manager would share evicted flows with the workers
while keeping the flows mutex locked. This reduced the number of unlock/
lock cycles while there was guaranteed to be no contention.

This turns out to be undefined behavior. A lock is supposed to be locked
and unlocked from the same thread. It appears that FreeBSD is stricter on
this than Linux.

This patch addresses the issue by unlocking before handing a flow off
to another thread, and locking again from the new thread.

Issue was reported and largely analyzed by Bill Meeks.

Bug: #4478

rust(lint): suppress clippy lints that we should fix

Suppress all remaining clippy lints that we trip. This can be
fixed on a per-lint basis.

rust(lint): remove manual implement of map method

Using `if let` expressions in these cases is better expressed
by the map method, and considered idiomatic Rust for this usage.

rust(lint): map the error instead of using or_else

This is the preffered style and easier to understand the meaning
of the code.

rust(lint): replace push_str of single char to push(<char>)

rust(lint): fix some usages of references

- ref is discouraged for top level variables
- the other borrow is not required

rust(lint): replace checked_mul with saturating_mul

When defaulting checked_mul to u64::max, Rust has a method
that does the same thing called saturating_mul.

rust(lint): removed unused unit () return

This is code that is not needed and is a bit confusing to see.

rust(lint): remove extra parens around bitwise or

This is a readability fix, as on first look they almost look
like a Rust tuple.

rust(lint): remove useless conversions and clones

These add complexity and may not be optimized out by the compiler.

rust(lint): remove useless format calls

In these simple cases to_string() is recommended and likely
performs better as the formatter is not called.

rust(lint): don't use unwrap_or for function calls

Calling a function in unwrap_or causes that function to always
be called even when not needed. Instead use unwrap_or_else with
a closure which will only be called when needed.

rust(lint): fix redundant closures

This lint checks for a closure where a function can be directly
supplied.  Runtime performance is unchanged, but this makes
less work for the compiler.

rust(lint): remove needless borrows

These are needless borrows (references) as the item is already
a reference.

rust: functions that reference raw pointers are unsafe

Based on the Rust clippy lint that recommends that any public
function that dereferences a raw pointer, mark all FFI functions
that reference raw pointers with build_slice and cast_pointer
as unsafe.

This commits starts by removing the unsafe wrapper inside
the build_slice and cast_pointer macros then marks all
functions that use these macros as unsafe.

Then fix all not_unsafe_ptr_arg_deref warnings from clippy.

Fixes clippy lint:
https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref

rust: remove all usage of transmute

All cases of our transmute can be replaced with more idiomatic
solutions and do no require the power of transmute.

When returning an object to C for life-time management, use
Box::into_raw to convert the boxed object to pointer and use
Box::from_raw to convert back.

For cases where we're just returning a pointer to Rust managed
data, use a cast.

output/redis: Fix possible segv

qa: use time on fuzz targets being run on corpus

stream-tcp-reassemble: fix typo, updt copyright yr

stream-tcp-reassemble: fix ConfGetBool unc'kd call

stream-tcp: fix typos, update copyright year

stream-tcp: fix ConfGetBool unchecked call

util-napatech: fix typos, update copyright year

util-napatech: fix ConfGetBool unchecked call

util-debug: fix unchecked ConfGetBool call

nfs: minor code cleanup

smb: minor formatting fixup

smb: minor code cleanup

smtp: fix clang fmt

nfs: fix comment

nfs: Add rust registration function

Get rid of the C glue code and move registration completely to Rust.

nfs: add missing code from rust impl of fns

nfs: Change fn sign as per rust registration requirement

Registering parsers in Rust requires signatures to be a certain way and
compatible with C. Change signatures of all the functions.
Probe fn has also been changed to return AppProto as required by the new
fn signature.

smb: Add rust registration function

Get rid of the C glue code and move registration completely to Rust.

smb: add missing code from rust impl of fns

smb: Change fn sign as per rust registration requirement

Registering parsers in Rust requires signatures to be a certain way and
compatible with C. Change signatures of all the functions.

smb: add constants

rust/core: Add flow flags

flow: provide flags accessor function

Add an accessor function for flow flags. To be used by Rust where
the flow struct is an opaque data type.

rust/applayer: add more externs

stream: check if ACK packet is outdated

Outdated packets are ACK packets w/o data that have an ACK value
lower than our last_ack and also don't have an SACK records that
are new.

This can happen when some packets come in later than others (possibly
due to different paths taken).

stream/sack: clean up includes

stream/sack: minor debug improvements

stream: minor debug additions

doc/dcerpc: add proto keywords

mqtt: enable in config and remove misleading comment

stream: update memcaps in code to match config

app-layer/pd: review bailout conditions

To take TCP window into account
And to actually bail out if we received too much data
where the limit is configured by stream.reassembly.depth

app-layer/pd: only consider actual available data

For size limit checks consider only available data at the stream start
and before any GAPS.

The old check would consider too much data if there were temporary gaps,
like when a data packet was in-window but (far) ahead of the expected
segment.

streaming/buffer: account sbb data size

When tracking data track the size of the blocks so that in case
of gaps we can still know how much data we hold.

detect/iprep: convert to FAIL/PASS API

modbus: do not claim to handle gaps

doc: Grammar Correction

counters: only print alerts if stats are enabled

detect: fix typos and update copyright year

detect: fix bug where rule without sid is accepted

Before, if Suricata parsed a rule without a 'sid' option, instead of
failing that rule, the rule was parsed and attributed a sid 0.
Changes to:
detect-parse:
- add logic to filter out rules without sid;
- change unittest which didn't have a sid, but used to pass.
detect-sid: add unittest for rules without sid or with sid: 0

fuzz: only build fuzz_sigpcap_aware if asked

With the other fuzz targets, and do not build it if fuzzpcap
is available but we did not want to build the fuzz targets

rust: fix warnings with nightly

stream/tcp: limit ACK validation

Only limit ACK value validation for packet where the ACK bit is
set.

stream/tcp: don't reject on bad ack

Not using a packet for the streaming analysis when a non zero
ACK value and ACK bit was unset was leading to evasion as it was
possible to start a session with a SYN packet with a non zero ACK
value to see the full TCP stream to escape all stream and application
layer detection.

This addresses CVE-2021-35063.

Fixes: fa692df37 ("stream: reject broken ACK packets")
Ticket: #4504.