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.

stream/tcp: update ack handling logic

Only update the ack value of a session for regular packets when
the ACK bit is set.

dns: improve probing parser

Checks opcode is valid
Checks additional_rr do not exceed message length
Better logic for incomplete cases

detect/files: fix buffer tracking with multiple files

mqtt: move sub/unsub limits into app-layer config

detect/mqtt: add topic inspection limit

We add a new 'mqtt.(un)subscribe-topic-match-limit' option
to allow a user to specify the maximum number of topics in
a MQTT SUBSCRIBE or UNSUBSCRIBE message to be evaluated
in detection.

smtp: null terminate before calling strtoul

by copying in a temporary buffer
as is done in ByteExtractString

swf: right input length for decompression

dcerpc: handles bigger inputs than 2^16

By comparing integers with the largest size

detect: use u32 for InspectionBufferMultipleForList

So that we do not have an endless loop casting index to
u16 and having more than 65536 buffers in one transaction

Changes for all protocols, even ones where it is impossible
to have such a pattern, so as to avoid bad pattern copy/paste
in the future

detect: set event if max inspect buffers exceeded

If a parser exceeds 1024 buffers we stop processing them and
set a detect event instead. This is to avoid parser bugs as well as
crafted bad traffic leading to resources starvation due to excessive
loops.

detect: fix multi inspect buffer issue; clean up

Fix multi inspect buffer API causing cleanup logic in the single
inspect buffer paths. This could lead to a buffer overrun in the
"to clear" logic.

Multi buffers now use InspectionBufferSetupMulti instead of
InspectionBuffer. This is enforced by a check in debug validation.

Simplify the multi inspect buffer setup code and update the callers.

detect: reformat events table

nfs: improve probing parser

Checks credentials flavor is known

enip: improve probing parser

Strict length for register sessions
NOP command must have options=0

config: fix null dereference in MacSetRegisterFlowStorage

Crash happens with
--set outputs.eve-json.types.files.force-magic=yes

modbus: use ascii character classes while parsin rule

As the rust regex crate is unicode aware, which was
not the case of the C version

rust: SCLogDebug is real nop when built as release

Before, even if there were no outputs, all the arguments
were evaluated, which could turn expensive

All variables which are used only in certain build configurations
are now prefixed by underscore to avoid warnings

http2: set Debug on structs

unittests: optimize RunmodeIsUnittests()

stream: packet to stream flags macro

packets: more detailed entry debug for detect/stream

files: construct with default, free on drop

Update protocols.

files: implement default support

rust: fix app-layer parser flags

This especially allows for SSH bypass to work

decode/vxlan: Delay var init until needed

This commit modifies the var initialization slightly until after
integrity checks have been performed.

general/typo: Correct typo

decode: Eliminate NULL pkt checks

This commit removes the NULL pkt check that each decoder performs as
this is a "can't happen" case.

thresholds: Fix buffer overflow in threshold context

th_entry is resized using ThresholdHashRealloc() every time a rule with
a threshold using by_rule tracking is added. The problem is that this is
done before the rules are reordered, so occasionally a rule with by_rule
tracking gets a higher signature number (after reordering) than the
number of th_entries allocated, causing Suricata to crash.

This commit fixes this by allocating th_entries after all the rules are
loaded and reordered.

Backtrace from core dump:

  Program terminated with signal SIGSEGV, Segmentation fault.

  #0  0x000000000051b381 in ThresholdHandlePacket (p=p@entry=0x7fb0080f3960, lookup_tsh=0x51, new_tsh=new_tsh@entry=0x7fb016c316e0, td=td@entry=0x14adedf0, sid=9800979, gid=1, pa=0x7fb0080f3b18)
      at detect-engine-threshold.c:415
  415>----                if (TIMEVAL_DIFF_SEC(p->ts, lookup_tsh->tv1) < td->seconds) {

Bug #4503.

thresholds: syntax fixes

Fix syntax of if statement in SigGetThresholdTypeIter()

thresholds: remove unneeded function argument

Remove packet pointer from SigGetThresholdTypeIter() as it is
unused.

doc/eve: common fields and alert updates

- update examples for both
- change app_proto from alert field to common field, as
  per JsonBuilder's changes.

doc/eve: fix typos

output: Fix possible null deref

This commit corrects an issue uncovered by Coverity. See the redmine
issue for details: https://redmine.openinfosecfoundation.org/issues/4495

http2: only mimic http1 request if there is one

That may not be the case in midstream/async configurations

makefile: don't include the whole test/ directory

Including the whole directory results in .deps files ending up
in the distribution archive which shouldn't be there. Instead
we have to list all the test sources individually.

rust/default: Enable Default usage

nfs: Rework constructs to use Self/Default

dhcp: Rework constructs to use Self/Default

dcerpc: Rework constructs to use Self/Default

dns: Rework constructs to use Self/Default

smb: Rework constructs to use Self/Default

This commit modifies the constructors to use Self and/or
Default::default() when feasible